//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2021 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto/tree/main/CodeGenerator. DO NOT EDIT.

import Foundation
import SotoCore

extension S3 {
    // MARK: Enums

    public enum AnalyticsS3ExportFileFormat: String, CustomStringConvertible, Codable {
        case csv = "CSV"
        public var description: String { return self.rawValue }
    }

    public enum ArchiveStatus: String, CustomStringConvertible, Codable {
        case archiveAccess = "ARCHIVE_ACCESS"
        case deepArchiveAccess = "DEEP_ARCHIVE_ACCESS"
        public var description: String { return self.rawValue }
    }

    public enum BucketAccelerateStatus: String, CustomStringConvertible, Codable {
        case enabled = "Enabled"
        case suspended = "Suspended"
        public var description: String { return self.rawValue }
    }

    public enum BucketCannedACL: String, CustomStringConvertible, Codable {
        case authenticatedRead = "authenticated-read"
        case `private`
        case publicRead = "public-read"
        case publicReadWrite = "public-read-write"
        public var description: String { return self.rawValue }
    }

    public struct BucketLocationConstraint: RawRepresentable, Equatable, Codable {
        public var rawValue: String

        public init(rawValue: String) {
            self.rawValue = rawValue
        }

        public static var afSouth1: Self { .init(rawValue: "af-south-1") }
        public static var apEast1: Self { .init(rawValue: "ap-east-1") }
        public static var apNortheast1: Self { .init(rawValue: "ap-northeast-1") }
        public static var apNortheast2: Self { .init(rawValue: "ap-northeast-2") }
        public static var apNortheast3: Self { .init(rawValue: "ap-northeast-3") }
        public static var apSouth1: Self { .init(rawValue: "ap-south-1") }
        public static var apSoutheast1: Self { .init(rawValue: "ap-southeast-1") }
        public static var apSoutheast2: Self { .init(rawValue: "ap-southeast-2") }
        public static var caCentral1: Self { .init(rawValue: "ca-central-1") }
        public static var cnNorth1: Self { .init(rawValue: "cn-north-1") }
        public static var cnNorthwest1: Self { .init(rawValue: "cn-northwest-1") }
        public static var eu: Self { .init(rawValue: "EU") }
        public static var euCentral1: Self { .init(rawValue: "eu-central-1") }
        public static var euNorth1: Self { .init(rawValue: "eu-north-1") }
        public static var euSouth1: Self { .init(rawValue: "eu-south-1") }
        public static var euWest1: Self { .init(rawValue: "eu-west-1") }
        public static var euWest2: Self { .init(rawValue: "eu-west-2") }
        public static var euWest3: Self { .init(rawValue: "eu-west-3") }
        public static var meSouth1: Self { .init(rawValue: "me-south-1") }
        public static var saEast1: Self { .init(rawValue: "sa-east-1") }
        public static var usEast1: Self { .init(rawValue: "us-east-1") }
        public static var usEast2: Self { .init(rawValue: "us-east-2") }
        public static var usGovEast1: Self { .init(rawValue: "us-gov-east-1") }
        public static var usGovWest1: Self { .init(rawValue: "us-gov-west-1") }
        public static var usWest1: Self { .init(rawValue: "us-west-1") }
        public static var usWest2: Self { .init(rawValue: "us-west-2") }
    }

    public enum BucketLogsPermission: String, CustomStringConvertible, Codable {
        case fullControl = "FULL_CONTROL"
        case read = "READ"
        case write = "WRITE"
        public var description: String { return self.rawValue }
    }

    public enum BucketVersioningStatus: String, CustomStringConvertible, Codable {
        case enabled = "Enabled"
        case suspended = "Suspended"
        public var description: String { return self.rawValue }
    }

    public enum CompressionType: String, CustomStringConvertible, Codable {
        case bzip2 = "BZIP2"
        case gzip = "GZIP"
        case none = "NONE"
        public var description: String { return self.rawValue }
    }

    public enum DeleteMarkerReplicationStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum EncodingType: String, CustomStringConvertible, Codable {
        case url
        public var description: String { return self.rawValue }
    }

    public enum Event: String, CustomStringConvertible, Codable {
        case s3ObjectcreatedAll = "s3:ObjectCreated:*"
        case s3ObjectcreatedCompletemultipartupload = "s3:ObjectCreated:CompleteMultipartUpload"
        case s3ObjectcreatedCopy = "s3:ObjectCreated:Copy"
        case s3ObjectcreatedPost = "s3:ObjectCreated:Post"
        case s3ObjectcreatedPut = "s3:ObjectCreated:Put"
        case s3ObjectremovedAll = "s3:ObjectRemoved:*"
        case s3ObjectremovedDelete = "s3:ObjectRemoved:Delete"
        case s3ObjectremovedDeletemarkercreated = "s3:ObjectRemoved:DeleteMarkerCreated"
        case s3ObjectrestoreAll = "s3:ObjectRestore:*"
        case s3ObjectrestoreCompleted = "s3:ObjectRestore:Completed"
        case s3ObjectrestorePost = "s3:ObjectRestore:Post"
        case s3Reducedredundancylostobject = "s3:ReducedRedundancyLostObject"
        case s3ReplicationAll = "s3:Replication:*"
        case s3ReplicationOperationfailedreplication = "s3:Replication:OperationFailedReplication"
        case s3ReplicationOperationmissedthreshold = "s3:Replication:OperationMissedThreshold"
        case s3ReplicationOperationnottracked = "s3:Replication:OperationNotTracked"
        case s3ReplicationOperationreplicatedafterthreshold = "s3:Replication:OperationReplicatedAfterThreshold"
        public var description: String { return self.rawValue }
    }

    public enum ExistingObjectReplicationStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum ExpirationStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum ExpressionType: String, CustomStringConvertible, Codable {
        case sql = "SQL"
        public var description: String { return self.rawValue }
    }

    public enum FileHeaderInfo: String, CustomStringConvertible, Codable {
        case ignore = "IGNORE"
        case none = "NONE"
        case use = "USE"
        public var description: String { return self.rawValue }
    }

    public enum FilterRuleName: String, CustomStringConvertible, Codable {
        case prefix
        case suffix
        public var description: String { return self.rawValue }
    }

    public enum IntelligentTieringAccessTier: String, CustomStringConvertible, Codable {
        case archiveAccess = "ARCHIVE_ACCESS"
        case deepArchiveAccess = "DEEP_ARCHIVE_ACCESS"
        public var description: String { return self.rawValue }
    }

    public enum IntelligentTieringStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum InventoryFormat: String, CustomStringConvertible, Codable {
        case csv = "CSV"
        case orc = "ORC"
        case parquet = "Parquet"
        public var description: String { return self.rawValue }
    }

    public enum InventoryFrequency: String, CustomStringConvertible, Codable {
        case daily = "Daily"
        case weekly = "Weekly"
        public var description: String { return self.rawValue }
    }

    public enum InventoryIncludedObjectVersions: String, CustomStringConvertible, Codable {
        case all = "All"
        case current = "Current"
        public var description: String { return self.rawValue }
    }

    public enum InventoryOptionalField: String, CustomStringConvertible, Codable {
        case encryptionstatus = "EncryptionStatus"
        case etag = "ETag"
        case intelligenttieringaccesstier = "IntelligentTieringAccessTier"
        case ismultipartuploaded = "IsMultipartUploaded"
        case lastmodifieddate = "LastModifiedDate"
        case objectlocklegalholdstatus = "ObjectLockLegalHoldStatus"
        case objectlockmode = "ObjectLockMode"
        case objectlockretainuntildate = "ObjectLockRetainUntilDate"
        case replicationstatus = "ReplicationStatus"
        case size = "Size"
        case storageclass = "StorageClass"
        public var description: String { return self.rawValue }
    }

    public enum JSONType: String, CustomStringConvertible, Codable {
        case document = "DOCUMENT"
        case lines = "LINES"
        public var description: String { return self.rawValue }
    }

    public enum MFADelete: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum MFADeleteStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum MetadataDirective: String, CustomStringConvertible, Codable {
        case copy = "COPY"
        case replace = "REPLACE"
        public var description: String { return self.rawValue }
    }

    public enum MetricsStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum ObjectCannedACL: String, CustomStringConvertible, Codable {
        case authenticatedRead = "authenticated-read"
        case awsExecRead = "aws-exec-read"
        case bucketOwnerFullControl = "bucket-owner-full-control"
        case bucketOwnerRead = "bucket-owner-read"
        case `private`
        case publicRead = "public-read"
        case publicReadWrite = "public-read-write"
        public var description: String { return self.rawValue }
    }

    public enum ObjectLockEnabled: String, CustomStringConvertible, Codable {
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum ObjectLockLegalHoldStatus: String, CustomStringConvertible, Codable {
        case off = "OFF"
        case on = "ON"
        public var description: String { return self.rawValue }
    }

    public enum ObjectLockMode: String, CustomStringConvertible, Codable {
        case compliance = "COMPLIANCE"
        case governance = "GOVERNANCE"
        public var description: String { return self.rawValue }
    }

    public enum ObjectLockRetentionMode: String, CustomStringConvertible, Codable {
        case compliance = "COMPLIANCE"
        case governance = "GOVERNANCE"
        public var description: String { return self.rawValue }
    }

    public enum ObjectOwnership: String, CustomStringConvertible, Codable {
        case bucketownerpreferred = "BucketOwnerPreferred"
        case objectwriter = "ObjectWriter"
        public var description: String { return self.rawValue }
    }

    public enum ObjectStorageClass: String, CustomStringConvertible, Codable {
        case deepArchive = "DEEP_ARCHIVE"
        case glacier = "GLACIER"
        case intelligentTiering = "INTELLIGENT_TIERING"
        case onezoneIa = "ONEZONE_IA"
        case outposts = "OUTPOSTS"
        case reducedRedundancy = "REDUCED_REDUNDANCY"
        case standard = "STANDARD"
        case standardIa = "STANDARD_IA"
        public var description: String { return self.rawValue }
    }

    public enum ObjectVersionStorageClass: String, CustomStringConvertible, Codable {
        case standard = "STANDARD"
        public var description: String { return self.rawValue }
    }

    public enum OwnerOverride: String, CustomStringConvertible, Codable {
        case destination = "Destination"
        public var description: String { return self.rawValue }
    }

    public enum Payer: String, CustomStringConvertible, Codable {
        case bucketowner = "BucketOwner"
        case requester = "Requester"
        public var description: String { return self.rawValue }
    }

    public enum Permission: String, CustomStringConvertible, Codable {
        case fullControl = "FULL_CONTROL"
        case read = "READ"
        case readAcp = "READ_ACP"
        case write = "WRITE"
        case writeAcp = "WRITE_ACP"
        public var description: String { return self.rawValue }
    }

    public enum `Protocol`: String, CustomStringConvertible, Codable {
        case http
        case https
        public var description: String { return self.rawValue }
    }

    public enum QuoteFields: String, CustomStringConvertible, Codable {
        case always = "ALWAYS"
        case asneeded = "ASNEEDED"
        public var description: String { return self.rawValue }
    }

    public enum ReplicaModificationsStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum ReplicationRuleStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum ReplicationStatus: String, CustomStringConvertible, Codable {
        case completed = "COMPLETED"
        case failed = "FAILED"
        case pending = "PENDING"
        case replica = "REPLICA"
        public var description: String { return self.rawValue }
    }

    public enum ReplicationTimeStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum RequestCharged: String, CustomStringConvertible, Codable {
        case requester
        public var description: String { return self.rawValue }
    }

    public enum RequestPayer: String, CustomStringConvertible, Codable {
        case requester
        public var description: String { return self.rawValue }
    }

    public enum RestoreRequestType: String, CustomStringConvertible, Codable {
        case select = "SELECT"
        public var description: String { return self.rawValue }
    }

    public enum ServerSideEncryption: String, CustomStringConvertible, Codable {
        case aes256 = "AES256"
        case awsKms = "aws:kms"
        public var description: String { return self.rawValue }
    }

    public enum SseKmsEncryptedObjectsStatus: String, CustomStringConvertible, Codable {
        case disabled = "Disabled"
        case enabled = "Enabled"
        public var description: String { return self.rawValue }
    }

    public enum StorageClass: String, CustomStringConvertible, Codable {
        case deepArchive = "DEEP_ARCHIVE"
        case glacier = "GLACIER"
        case intelligentTiering = "INTELLIGENT_TIERING"
        case onezoneIa = "ONEZONE_IA"
        case outposts = "OUTPOSTS"
        case reducedRedundancy = "REDUCED_REDUNDANCY"
        case standard = "STANDARD"
        case standardIa = "STANDARD_IA"
        public var description: String { return self.rawValue }
    }

    public enum StorageClassAnalysisSchemaVersion: String, CustomStringConvertible, Codable {
        case v1 = "V_1"
        public var description: String { return self.rawValue }
    }

    public enum TaggingDirective: String, CustomStringConvertible, Codable {
        case copy = "COPY"
        case replace = "REPLACE"
        public var description: String { return self.rawValue }
    }

    public enum Tier: String, CustomStringConvertible, Codable {
        case bulk = "Bulk"
        case expedited = "Expedited"
        case standard = "Standard"
        public var description: String { return self.rawValue }
    }

    public enum TransitionStorageClass: String, CustomStringConvertible, Codable {
        case deepArchive = "DEEP_ARCHIVE"
        case glacier = "GLACIER"
        case intelligentTiering = "INTELLIGENT_TIERING"
        case onezoneIa = "ONEZONE_IA"
        case standardIa = "STANDARD_IA"
        public var description: String { return self.rawValue }
    }

    public enum `Type`: String, CustomStringConvertible, Codable {
        case amazoncustomerbyemail = "AmazonCustomerByEmail"
        case canonicaluser = "CanonicalUser"
        case group = "Group"
        public var description: String { return self.rawValue }
    }

    // MARK: Shapes

    public struct AbortIncompleteMultipartUpload: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.
        public let daysAfterInitiation: Int?

        public init(daysAfterInitiation: Int? = nil) {
            self.daysAfterInitiation = daysAfterInitiation
        }

        private enum CodingKeys: String, CodingKey {
            case daysAfterInitiation = "DaysAfterInitiation"
        }
    }

    public struct AbortMultipartUploadOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        public let requestCharged: RequestCharged?

        public init(requestCharged: RequestCharged? = nil) {
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct AbortMultipartUploadRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "uploadId", location: .querystring(locationName: "uploadId"))
        ]

        /// The bucket name to which the upload was taking place.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Key of the object for which the multipart upload was initiated.
        public let key: String
        public let requestPayer: RequestPayer?
        /// Upload ID that identifies the multipart upload.
        public let uploadId: String

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, uploadId: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.uploadId = uploadId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct AccelerateConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies the transfer acceleration status of the bucket.
        public let status: BucketAccelerateStatus?

        public init(status: BucketAccelerateStatus? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct AccessControlPolicy: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"
        public struct _GrantsEncoding: ArrayCoderProperties { public static let member = "Grant" }

        /// A list of grants.
        @OptionalCustomCoding<ArrayCoder<_GrantsEncoding, Grant>>
        public var grants: [Grant]?
        /// Container for the bucket owner's display name and ID.
        public let owner: Owner?

        public init(grants: [Grant]? = nil, owner: Owner? = nil) {
            self.grants = grants
            self.owner = owner
        }

        private enum CodingKeys: String, CodingKey {
            case grants = "AccessControlList"
            case owner = "Owner"
        }
    }

    public struct AccessControlTranslation: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the replica ownership. For default and valid values, see PUT bucket replication in the Amazon Simple Storage Service API Reference.
        public let owner: OwnerOverride

        public init(owner: OwnerOverride) {
            self.owner = owner
        }

        private enum CodingKeys: String, CodingKey {
            case owner = "Owner"
        }
    }

    public struct AnalyticsAndOperator: AWSEncodableShape & AWSDecodableShape {
        /// The prefix to use when evaluating an AND predicate: The prefix that an object must have to be included in the metrics results.
        public let prefix: String?
        /// The list of tags to use when evaluating an AND predicate.
        public let tags: [Tag]?

        public init(prefix: String? = nil, tags: [Tag]? = nil) {
            self.prefix = prefix
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
            case tags = "Tag"
        }
    }

    public struct AnalyticsConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// The filter used to describe a set of objects for analyses. A filter must have exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator). If no filter is provided, all objects will be considered in any analysis.
        public let filter: AnalyticsFilter?
        /// The ID that identifies the analytics configuration.
        public let id: String
        ///  Contains data related to access patterns to be collected and made available to analyze the tradeoffs between different storage classes.
        public let storageClassAnalysis: StorageClassAnalysis

        public init(filter: AnalyticsFilter? = nil, id: String, storageClassAnalysis: StorageClassAnalysis) {
            self.filter = filter
            self.id = id
            self.storageClassAnalysis = storageClassAnalysis
        }

        public func validate(name: String) throws {
            try self.filter?.validate(name: "\(name).filter")
        }

        private enum CodingKeys: String, CodingKey {
            case filter = "Filter"
            case id = "Id"
            case storageClassAnalysis = "StorageClassAnalysis"
        }
    }

    public struct AnalyticsExportDestination: AWSEncodableShape & AWSDecodableShape {
        /// A destination signifying output to an S3 bucket.
        public let s3BucketDestination: AnalyticsS3BucketDestination

        public init(s3BucketDestination: AnalyticsS3BucketDestination) {
            self.s3BucketDestination = s3BucketDestination
        }

        private enum CodingKeys: String, CodingKey {
            case s3BucketDestination = "S3BucketDestination"
        }
    }

    public struct AnalyticsFilter: AWSEncodableShape & AWSDecodableShape {
        /// A conjunction (logical AND) of predicates, which is used in evaluating an analytics filter. The operator must have at least two predicates.
        public let and: AnalyticsAndOperator?
        /// The prefix to use when evaluating an analytics filter.
        public let prefix: String?
        /// The tag to use when evaluating an analytics filter.
        public let tag: Tag?

        public init(and: AnalyticsAndOperator? = nil, prefix: String? = nil, tag: Tag? = nil) {
            self.and = and
            self.prefix = prefix
            self.tag = tag
        }

        public func validate(name: String) throws {
            try self.and?.validate(name: "\(name).and")
            try self.tag?.validate(name: "\(name).tag")
        }

        private enum CodingKeys: String, CodingKey {
            case and = "And"
            case prefix = "Prefix"
            case tag = "Tag"
        }
    }

    public struct AnalyticsS3BucketDestination: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the bucket to which data is exported.
        public let bucket: String
        /// The account ID that owns the destination S3 bucket. If no account ID is provided, the owner is not validated before exporting data.   Although this value is optional, we strongly recommend that you set it to help prevent problems if the destination bucket ownership changes.
        public let bucketAccountId: String?
        /// Specifies the file format used when exporting data to Amazon S3.
        public let format: AnalyticsS3ExportFileFormat
        /// The prefix to use when exporting data. The prefix is prepended to all results.
        public let prefix: String?

        public init(bucket: String, bucketAccountId: String? = nil, format: AnalyticsS3ExportFileFormat, prefix: String? = nil) {
            self.bucket = bucket
            self.bucketAccountId = bucketAccountId
            self.format = format
            self.prefix = prefix
        }

        private enum CodingKeys: String, CodingKey {
            case bucket = "Bucket"
            case bucketAccountId = "BucketAccountId"
            case format = "Format"
            case prefix = "Prefix"
        }
    }

    public struct Bucket: AWSDecodableShape {
        /// Date the bucket was created. This date can change when making changes to your bucket, such as editing its bucket policy.
        public let creationDate: Date?
        /// The name of the bucket.
        public let name: String?

        public init(creationDate: Date? = nil, name: String? = nil) {
            self.creationDate = creationDate
            self.name = name
        }

        private enum CodingKeys: String, CodingKey {
            case creationDate = "CreationDate"
            case name = "Name"
        }
    }

    public struct BucketLifecycleConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// A lifecycle rule for individual objects in an Amazon S3 bucket.
        public let rules: [LifecycleRule]

        public init(rules: [LifecycleRule]) {
            self.rules = rules
        }

        public func validate(name: String) throws {
            try self.rules.forEach {
                try $0.validate(name: "\(name).rules[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case rules = "Rule"
        }
    }

    public struct BucketLoggingStatus: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        public let loggingEnabled: LoggingEnabled?

        public init(loggingEnabled: LoggingEnabled? = nil) {
            self.loggingEnabled = loggingEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case loggingEnabled = "LoggingEnabled"
        }
    }

    public struct CORSConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.
        public let cORSRules: [CORSRule]

        public init(cORSRules: [CORSRule]) {
            self.cORSRules = cORSRules
        }

        private enum CodingKeys: String, CodingKey {
            case cORSRules = "CORSRule"
        }
    }

    public struct CORSRule: AWSEncodableShape & AWSDecodableShape {
        /// Headers that are specified in the Access-Control-Request-Headers header. These headers are allowed in a preflight OPTIONS request. In response to any preflight OPTIONS request, Amazon S3 returns any requested headers that are allowed.
        public let allowedHeaders: [String]?
        /// An HTTP method that you allow the origin to execute. Valid values are GET, PUT, HEAD, POST, and DELETE.
        public let allowedMethods: [String]
        /// One or more origins you want customers to be able to access the bucket from.
        public let allowedOrigins: [String]
        /// One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
        public let exposeHeaders: [String]?
        /// The time in seconds that your browser is to cache the preflight response for the specified resource.
        public let maxAgeSeconds: Int?

        public init(allowedHeaders: [String]? = nil, allowedMethods: [String], allowedOrigins: [String], exposeHeaders: [String]? = nil, maxAgeSeconds: Int? = nil) {
            self.allowedHeaders = allowedHeaders
            self.allowedMethods = allowedMethods
            self.allowedOrigins = allowedOrigins
            self.exposeHeaders = exposeHeaders
            self.maxAgeSeconds = maxAgeSeconds
        }

        private enum CodingKeys: String, CodingKey {
            case allowedHeaders = "AllowedHeader"
            case allowedMethods = "AllowedMethod"
            case allowedOrigins = "AllowedOrigin"
            case exposeHeaders = "ExposeHeader"
            case maxAgeSeconds = "MaxAgeSeconds"
        }
    }

    public struct CSVInput: AWSEncodableShape {
        /// Specifies that CSV field values may contain quoted record delimiters and such records should be allowed. Default value is FALSE. Setting this value to TRUE may lower performance.
        public let allowQuotedRecordDelimiter: Bool?
        /// A single character used to indicate that a row should be ignored when the character is present at the start of that row. You can specify any character to indicate a comment line.
        public let comments: String?
        /// A single character used to separate individual fields in a record. You can specify an arbitrary delimiter.
        public let fieldDelimiter: String?
        /// Describes the first line of input. Valid values are:    NONE: First line is not a header.    IGNORE: First line is a header, but you can't use the header values to indicate the column in an expression. You can use column position (such as _1, _2, …) to indicate the column (SELECT s._1 FROM OBJECT s).    Use: First line is a header, and you can use the header value to identify a column in an expression (SELECT "name" FROM OBJECT).
        public let fileHeaderInfo: FileHeaderInfo?
        /// A single character used for escaping when the field delimiter is part of the value. For example, if the value is a, b, Amazon S3 wraps this field value in quotation marks, as follows: " a , b ". Type: String Default: "  Ancestors: CSV
        public let quoteCharacter: String?
        /// A single character used for escaping the quotation mark character inside an already escaped value. For example, the value """ a , b """ is parsed as " a , b ".
        public let quoteEscapeCharacter: String?
        /// A single character used to separate individual records in the input. Instead of the default value, you can specify an arbitrary delimiter.
        public let recordDelimiter: String?

        public init(allowQuotedRecordDelimiter: Bool? = nil, comments: String? = nil, fieldDelimiter: String? = nil, fileHeaderInfo: FileHeaderInfo? = nil, quoteCharacter: String? = nil, quoteEscapeCharacter: String? = nil, recordDelimiter: String? = nil) {
            self.allowQuotedRecordDelimiter = allowQuotedRecordDelimiter
            self.comments = comments
            self.fieldDelimiter = fieldDelimiter
            self.fileHeaderInfo = fileHeaderInfo
            self.quoteCharacter = quoteCharacter
            self.quoteEscapeCharacter = quoteEscapeCharacter
            self.recordDelimiter = recordDelimiter
        }

        private enum CodingKeys: String, CodingKey {
            case allowQuotedRecordDelimiter = "AllowQuotedRecordDelimiter"
            case comments = "Comments"
            case fieldDelimiter = "FieldDelimiter"
            case fileHeaderInfo = "FileHeaderInfo"
            case quoteCharacter = "QuoteCharacter"
            case quoteEscapeCharacter = "QuoteEscapeCharacter"
            case recordDelimiter = "RecordDelimiter"
        }
    }

    public struct CSVOutput: AWSEncodableShape {
        /// The value used to separate individual fields in a record. You can specify an arbitrary delimiter.
        public let fieldDelimiter: String?
        /// A single character used for escaping when the field delimiter is part of the value. For example, if the value is a, b, Amazon S3 wraps this field value in quotation marks, as follows: " a , b ".
        public let quoteCharacter: String?
        /// The single character used for escaping the quote character inside an already escaped value.
        public let quoteEscapeCharacter: String?
        /// Indicates whether to use quotation marks around output fields.     ALWAYS: Always use quotation marks for output fields.    ASNEEDED: Use quotation marks for output fields when needed.
        public let quoteFields: QuoteFields?
        /// A single character used to separate individual records in the output. Instead of the default value, you can specify an arbitrary delimiter.
        public let recordDelimiter: String?

        public init(fieldDelimiter: String? = nil, quoteCharacter: String? = nil, quoteEscapeCharacter: String? = nil, quoteFields: QuoteFields? = nil, recordDelimiter: String? = nil) {
            self.fieldDelimiter = fieldDelimiter
            self.quoteCharacter = quoteCharacter
            self.quoteEscapeCharacter = quoteEscapeCharacter
            self.quoteFields = quoteFields
            self.recordDelimiter = recordDelimiter
        }

        private enum CodingKeys: String, CodingKey {
            case fieldDelimiter = "FieldDelimiter"
            case quoteCharacter = "QuoteCharacter"
            case quoteEscapeCharacter = "QuoteEscapeCharacter"
            case quoteFields = "QuoteFields"
            case recordDelimiter = "RecordDelimiter"
        }
    }

    public struct CloudFunctionConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// Lambda cloud function ARN that Amazon S3 can invoke when it detects events of the specified type.
        public let cloudFunction: String?
        /// Bucket events for which to send notifications.
        public let events: [Event]?
        public let id: String?
        /// The role supporting the invocation of the Lambda function
        public let invocationRole: String?

        public init(cloudFunction: String? = nil, events: [Event]? = nil, id: String? = nil, invocationRole: String? = nil) {
            self.cloudFunction = cloudFunction
            self.events = events
            self.id = id
            self.invocationRole = invocationRole
        }

        private enum CodingKeys: String, CodingKey {
            case cloudFunction = "CloudFunction"
            case events = "Event"
            case id = "Id"
            case invocationRole = "InvocationRole"
        }
    }

    public struct CommonPrefix: AWSDecodableShape {
        /// Container for the specified common prefix.
        public let prefix: String?

        public init(prefix: String? = nil) {
            self.prefix = prefix
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
        }
    }

    public struct CompleteMultipartUploadOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "expiration", location: .header(locationName: "x-amz-expiration")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]

        /// The name of the bucket that contains the newly created object. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String?
        /// Indicates whether the multipart upload uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Entity tag that identifies the newly created object's data. Objects with different object data will have different entity tags. The entity tag is an opaque string. The entity tag may or may not be an MD5 digest of the object data. If the entity tag is not an MD5 digest of the object data, it will contain one or more nonhexadecimal characters and/or will consist of less than 32 or more than 32 hexadecimal digits.
        public let eTag: String?
        /// If the object expiration is configured, this will contain the expiration date (expiry-date) and rule ID (rule-id). The value of rule-id is URL encoded.
        public let expiration: String?
        /// The object key of the newly created object.
        public let key: String?
        /// The URI that identifies the newly created object.
        public let location: String?
        public let requestCharged: RequestCharged?
        /// If you specified server-side encryption either with an Amazon S3-managed encryption key or an AWS KMS customer master key (CMK) in your initiate multipart upload request, the response includes this header. It confirms the encryption algorithm that Amazon S3 used to encrypt the object.
        public let serverSideEncryption: ServerSideEncryption?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?
        /// Version ID of the newly created object, in case the bucket has versioning turned on.
        public let versionId: String?

        public init(bucket: String? = nil, bucketKeyEnabled: Bool? = nil, eTag: String? = nil, expiration: String? = nil, key: String? = nil, location: String? = nil, requestCharged: RequestCharged? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSEKMSKeyId: String? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.bucketKeyEnabled = bucketKeyEnabled
            self.eTag = eTag
            self.expiration = expiration
            self.key = key
            self.location = location
            self.requestCharged = requestCharged
            self.serverSideEncryption = serverSideEncryption
            self.sSEKMSKeyId = sSEKMSKeyId
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case bucket = "Bucket"
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case eTag = "ETag"
            case expiration = "x-amz-expiration"
            case key = "Key"
            case location = "Location"
            case requestCharged = "x-amz-request-charged"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
            case versionId = "x-amz-version-id"
        }
    }

    public struct CompleteMultipartUploadRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "multipartUpload"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "multipartUpload", location: .body(locationName: "CompleteMultipartUpload")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "uploadId", location: .querystring(locationName: "uploadId"))
        ]

        /// Name of the bucket to which the multipart upload was initiated.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Object key for which the multipart upload was initiated.
        public let key: String
        /// The container for the multipart upload request information.
        public let multipartUpload: CompletedMultipartUpload?
        public let requestPayer: RequestPayer?
        /// ID for the initiated multipart upload.
        public let uploadId: String

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, multipartUpload: CompletedMultipartUpload? = nil, requestPayer: RequestPayer? = nil, uploadId: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.multipartUpload = multipartUpload
            self.requestPayer = requestPayer
            self.uploadId = uploadId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case multipartUpload = "CompleteMultipartUpload"
        }
    }

    public struct CompletedMultipartUpload: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Array of CompletedPart data types.
        public let parts: [CompletedPart]?

        public init(parts: [CompletedPart]? = nil) {
            self.parts = parts
        }

        private enum CodingKeys: String, CodingKey {
            case parts = "Part"
        }
    }

    public struct CompletedPart: AWSEncodableShape {
        /// Entity tag returned when the part was uploaded.
        public let eTag: String?
        /// Part number that identifies the part. This is a positive integer between 1 and 10,000.
        public let partNumber: Int?

        public init(eTag: String? = nil, partNumber: Int? = nil) {
            self.eTag = eTag
            self.partNumber = partNumber
        }

        private enum CodingKeys: String, CodingKey {
            case eTag = "ETag"
            case partNumber = "PartNumber"
        }
    }

    public struct Condition: AWSEncodableShape & AWSDecodableShape {
        /// The HTTP error code when the redirect is applied. In the event of an error, if the error code equals this value, then the specified redirect is applied. Required when parent element Condition is specified and sibling KeyPrefixEquals is not specified. If both are specified, then both must be true for the redirect to be applied.
        public let httpErrorCodeReturnedEquals: String?
        /// The object key name prefix when the redirect is applied. For example, to redirect requests for ExamplePage.html, the key prefix will be ExamplePage.html. To redirect request for all pages with the prefix docs/, the key prefix will be /docs, which identifies all objects in the docs/ folder. Required when the parent element Condition is specified and sibling HttpErrorCodeReturnedEquals is not specified. If both conditions are specified, both must be true for the redirect to be applied.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let keyPrefixEquals: String?

        public init(httpErrorCodeReturnedEquals: String? = nil, keyPrefixEquals: String? = nil) {
            self.httpErrorCodeReturnedEquals = httpErrorCodeReturnedEquals
            self.keyPrefixEquals = keyPrefixEquals
        }

        private enum CodingKeys: String, CodingKey {
            case httpErrorCodeReturnedEquals = "HttpErrorCodeReturnedEquals"
            case keyPrefixEquals = "KeyPrefixEquals"
        }
    }

    public struct ContinuationEvent: AWSDecodableShape {
        public init() {}
    }

    public struct CopyObjectOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "copyObjectResult"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "copyObjectResult", location: .body(locationName: "CopyObjectResult")),
            AWSMemberEncoding(label: "copySourceVersionId", location: .header(locationName: "x-amz-copy-source-version-id")),
            AWSMemberEncoding(label: "expiration", location: .header(locationName: "x-amz-expiration")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSEncryptionContext", location: .header(locationName: "x-amz-server-side-encryption-context")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]

        /// Indicates whether the copied object uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Container for all response elements.
        public let copyObjectResult: CopyObjectResult?
        /// Version of the copied object in the destination bucket.
        public let copySourceVersionId: String?
        /// If the object expiration is configured, the response includes this header.
        public let expiration: String?
        public let requestCharged: RequestCharged?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the AWS KMS Encryption Context to use for object encryption. The value of this header is a base64-encoded UTF-8 string holding JSON with the encryption context key-value pairs.
        public let sSEKMSEncryptionContext: String?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?
        /// Version ID of the newly created copy.
        public let versionId: String?

        public init(bucketKeyEnabled: Bool? = nil, copyObjectResult: CopyObjectResult? = nil, copySourceVersionId: String? = nil, expiration: String? = nil, requestCharged: RequestCharged? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSEncryptionContext: String? = nil, sSEKMSKeyId: String? = nil, versionId: String? = nil) {
            self.bucketKeyEnabled = bucketKeyEnabled
            self.copyObjectResult = copyObjectResult
            self.copySourceVersionId = copySourceVersionId
            self.expiration = expiration
            self.requestCharged = requestCharged
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSEncryptionContext = sSEKMSEncryptionContext
            self.sSEKMSKeyId = sSEKMSKeyId
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case copyObjectResult = "CopyObjectResult"
            case copySourceVersionId = "x-amz-copy-source-version-id"
            case expiration = "x-amz-expiration"
            case requestCharged = "x-amz-request-charged"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSEncryptionContext = "x-amz-server-side-encryption-context"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
            case versionId = "x-amz-version-id"
        }
    }

    public struct CopyObjectRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "acl", location: .header(locationName: "x-amz-acl")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "cacheControl", location: .header(locationName: "Cache-Control")),
            AWSMemberEncoding(label: "contentDisposition", location: .header(locationName: "Content-Disposition")),
            AWSMemberEncoding(label: "contentEncoding", location: .header(locationName: "Content-Encoding")),
            AWSMemberEncoding(label: "contentLanguage", location: .header(locationName: "Content-Language")),
            AWSMemberEncoding(label: "contentType", location: .header(locationName: "Content-Type")),
            AWSMemberEncoding(label: "copySource", location: .header(locationName: "x-amz-copy-source")),
            AWSMemberEncoding(label: "copySourceIfMatch", location: .header(locationName: "x-amz-copy-source-if-match")),
            AWSMemberEncoding(label: "_copySourceIfModifiedSince", location: .header(locationName: "x-amz-copy-source-if-modified-since")),
            AWSMemberEncoding(label: "copySourceIfNoneMatch", location: .header(locationName: "x-amz-copy-source-if-none-match")),
            AWSMemberEncoding(label: "_copySourceIfUnmodifiedSince", location: .header(locationName: "x-amz-copy-source-if-unmodified-since")),
            AWSMemberEncoding(label: "copySourceSSECustomerAlgorithm", location: .header(locationName: "x-amz-copy-source-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "copySourceSSECustomerKey", location: .header(locationName: "x-amz-copy-source-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "copySourceSSECustomerKeyMD5", location: .header(locationName: "x-amz-copy-source-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "expectedSourceBucketOwner", location: .header(locationName: "x-amz-source-expected-bucket-owner")),
            AWSMemberEncoding(label: "_expires", location: .header(locationName: "Expires")),
            AWSMemberEncoding(label: "grantFullControl", location: .header(locationName: "x-amz-grant-full-control")),
            AWSMemberEncoding(label: "grantRead", location: .header(locationName: "x-amz-grant-read")),
            AWSMemberEncoding(label: "grantReadACP", location: .header(locationName: "x-amz-grant-read-acp")),
            AWSMemberEncoding(label: "grantWriteACP", location: .header(locationName: "x-amz-grant-write-acp")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "metadata", location: .header(locationName: "x-amz-meta-")),
            AWSMemberEncoding(label: "metadataDirective", location: .header(locationName: "x-amz-metadata-directive")),
            AWSMemberEncoding(label: "objectLockLegalHoldStatus", location: .header(locationName: "x-amz-object-lock-legal-hold")),
            AWSMemberEncoding(label: "objectLockMode", location: .header(locationName: "x-amz-object-lock-mode")),
            AWSMemberEncoding(label: "_objectLockRetainUntilDate", location: .header(locationName: "x-amz-object-lock-retain-until-date")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSEncryptionContext", location: .header(locationName: "x-amz-server-side-encryption-context")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "storageClass", location: .header(locationName: "x-amz-storage-class")),
            AWSMemberEncoding(label: "tagging", location: .header(locationName: "x-amz-tagging")),
            AWSMemberEncoding(label: "taggingDirective", location: .header(locationName: "x-amz-tagging-directive")),
            AWSMemberEncoding(label: "websiteRedirectLocation", location: .header(locationName: "x-amz-website-redirect-location"))
        ]

        /// The canned ACL to apply to the object. This action is not supported by Amazon S3 on Outposts.
        public let acl: ObjectCannedACL?
        /// The name of the destination bucket. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption with server-side encryption using AWS KMS (SSE-KMS). Setting this header to true causes Amazon S3 to use an S3 Bucket Key for object encryption with SSE-KMS.  Specifying this header with a COPY operation doesn’t affect bucket-level settings for S3 Bucket Key.
        public let bucketKeyEnabled: Bool?
        /// Specifies caching behavior along the request/reply chain.
        public let cacheControl: String?
        /// Specifies presentational information for the object.
        public let contentDisposition: String?
        /// Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field.
        public let contentEncoding: String?
        /// The language the content is in.
        public let contentLanguage: String?
        /// A standard MIME type describing the format of the object data.
        public let contentType: String?
        /// Specifies the source object for the copy operation. You specify the value in one of two formats, depending on whether you want to access the source object through an access point:   For objects not accessed through an access point, specify the name of the source bucket and the key of the source object, separated by a slash (/). For example, to copy the object reports/january.pdf from the bucket awsexamplebucket, use awsexamplebucket/reports/january.pdf. The value must be URL encoded.   For objects accessed through access points, specify the Amazon Resource Name (ARN) of the object as accessed through the access point, in the format arn:aws:s3:&lt;Region&gt;:&lt;account-id&gt;:accesspoint/&lt;access-point-name&gt;/object/&lt;key&gt;. For example, to copy the object reports/january.pdf through access point my-access-point owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point/object/reports/january.pdf. The value must be URL encoded.  Amazon S3 supports copy operations using access points only when the source and destination buckets are in the same AWS Region.  Alternatively, for objects accessed through Amazon S3 on Outposts, specify the ARN of the object as accessed in the format arn:aws:s3-outposts:&lt;Region&gt;:&lt;account-id&gt;:outpost/&lt;outpost-id&gt;/object/&lt;key&gt;. For example, to copy the object reports/january.pdf through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/object/reports/january.pdf. The value must be URL encoded.    To copy a specific version of an object, append ?versionId=&lt;version-id&gt; to the value (for example, awsexamplebucket/reports/january.pdf?versionId=QUpfdndhfd8438MNFDN93jdnJFkdmqnh893). If you don't specify a version ID, Amazon S3 copies the latest version of the source object.
        public let copySource: String
        /// Copies the object if its entity tag (ETag) matches the specified tag.
        public let copySourceIfMatch: String?
        /// Copies the object if it has been modified since the specified time.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var copySourceIfModifiedSince: Date?
        /// Copies the object if its entity tag (ETag) is different than the specified ETag.
        public let copySourceIfNoneMatch: String?
        /// Copies the object if it hasn't been modified since the specified time.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var copySourceIfUnmodifiedSince: Date?
        /// Specifies the algorithm to use when decrypting the source object (for example, AES256).
        public let copySourceSSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use to decrypt the source object. The encryption key provided in this header must be one that was used when the source object was created.
        public let copySourceSSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let copySourceSSECustomerKeyMD5: String?
        /// The account id of the expected destination bucket owner. If the destination bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The account id of the expected source bucket owner. If the source bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedSourceBucketOwner: String?
        /// The date and time at which the object is no longer cacheable.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var expires: Date?
        /// Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object. This action is not supported by Amazon S3 on Outposts.
        public let grantFullControl: String?
        /// Allows grantee to read the object data and its metadata. This action is not supported by Amazon S3 on Outposts.
        public let grantRead: String?
        /// Allows grantee to read the object ACL. This action is not supported by Amazon S3 on Outposts.
        public let grantReadACP: String?
        /// Allows grantee to write the ACL for the applicable object. This action is not supported by Amazon S3 on Outposts.
        public let grantWriteACP: String?
        /// The key of the destination object.
        public let key: String
        /// A map of metadata to store with the object in S3.
        public let metadata: [String: String]?
        /// Specifies whether the metadata is copied from the source object or replaced with metadata provided in the request.
        public let metadataDirective: MetadataDirective?
        /// Specifies whether you want to apply a Legal Hold to the copied object.
        public let objectLockLegalHoldStatus: ObjectLockLegalHoldStatus?
        /// The Object Lock mode that you want to apply to the copied object.
        public let objectLockMode: ObjectLockMode?
        /// The date and time when you want the copied object's Object Lock to expire.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var objectLockRetainUntilDate: Date?
        public let requestPayer: RequestPayer?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// Specifies the algorithm to use to when encrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This value is used to store the object and then it is discarded; Amazon S3 does not store the encryption key. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// Specifies the AWS KMS Encryption Context to use for object encryption. The value of this header is a base64-encoded UTF-8 string holding JSON with the encryption context key-value pairs.
        public let sSEKMSEncryptionContext: String?
        /// Specifies the AWS KMS key ID to use for object encryption. All GET and PUT requests for an object protected by AWS KMS will fail if not made via SSL or using SigV4. For information about configuring using any of the officially supported AWS SDKs and AWS CLI, see Specifying the Signature Version in Request Authentication in the Amazon S3 Developer Guide.
        public let sSEKMSKeyId: String?
        /// By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. Amazon S3 on Outposts only uses the OUTPOSTS Storage Class. For more information, see Storage Classes in the Amazon S3 Service Developer Guide.
        public let storageClass: StorageClass?
        /// The tag-set for the object destination object this value must be used in conjunction with the TaggingDirective. The tag-set must be encoded as URL Query parameters.
        public let tagging: String?
        /// Specifies whether the object tag-set are copied from the source object or replaced with tag-set provided in the request.
        public let taggingDirective: TaggingDirective?
        /// If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.
        public let websiteRedirectLocation: String?

        public init(acl: ObjectCannedACL? = nil, bucket: String, bucketKeyEnabled: Bool? = nil, cacheControl: String? = nil, contentDisposition: String? = nil, contentEncoding: String? = nil, contentLanguage: String? = nil, contentType: String? = nil, copySource: String, copySourceIfMatch: String? = nil, copySourceIfModifiedSince: Date? = nil, copySourceIfNoneMatch: String? = nil, copySourceIfUnmodifiedSince: Date? = nil, copySourceSSECustomerAlgorithm: String? = nil, copySourceSSECustomerKey: String? = nil, copySourceSSECustomerKeyMD5: String? = nil, expectedBucketOwner: String? = nil, expectedSourceBucketOwner: String? = nil, expires: Date? = nil, grantFullControl: String? = nil, grantRead: String? = nil, grantReadACP: String? = nil, grantWriteACP: String? = nil, key: String, metadata: [String: String]? = nil, metadataDirective: MetadataDirective? = nil, objectLockLegalHoldStatus: ObjectLockLegalHoldStatus? = nil, objectLockMode: ObjectLockMode? = nil, objectLockRetainUntilDate: Date? = nil, requestPayer: RequestPayer? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSEncryptionContext: String? = nil, sSEKMSKeyId: String? = nil, storageClass: StorageClass? = nil, tagging: String? = nil, taggingDirective: TaggingDirective? = nil, websiteRedirectLocation: String? = nil) {
            self.acl = acl
            self.bucket = bucket
            self.bucketKeyEnabled = bucketKeyEnabled
            self.cacheControl = cacheControl
            self.contentDisposition = contentDisposition
            self.contentEncoding = contentEncoding
            self.contentLanguage = contentLanguage
            self.contentType = contentType
            self.copySource = copySource
            self.copySourceIfMatch = copySourceIfMatch
            self.copySourceIfModifiedSince = copySourceIfModifiedSince
            self.copySourceIfNoneMatch = copySourceIfNoneMatch
            self.copySourceIfUnmodifiedSince = copySourceIfUnmodifiedSince
            self.copySourceSSECustomerAlgorithm = copySourceSSECustomerAlgorithm
            self.copySourceSSECustomerKey = copySourceSSECustomerKey
            self.copySourceSSECustomerKeyMD5 = copySourceSSECustomerKeyMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.expectedSourceBucketOwner = expectedSourceBucketOwner
            self.expires = expires
            self.grantFullControl = grantFullControl
            self.grantRead = grantRead
            self.grantReadACP = grantReadACP
            self.grantWriteACP = grantWriteACP
            self.key = key
            self.metadata = metadata
            self.metadataDirective = metadataDirective
            self.objectLockLegalHoldStatus = objectLockLegalHoldStatus
            self.objectLockMode = objectLockMode
            self.objectLockRetainUntilDate = objectLockRetainUntilDate
            self.requestPayer = requestPayer
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSEncryptionContext = sSEKMSEncryptionContext
            self.sSEKMSKeyId = sSEKMSKeyId
            self.storageClass = storageClass
            self.tagging = tagging
            self.taggingDirective = taggingDirective
            self.websiteRedirectLocation = websiteRedirectLocation
        }

        public func validate(name: String) throws {
            try self.validate(self.copySource, name: "copySource", parent: name, pattern: ".+\\/.+")
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct CopyObjectResult: AWSDecodableShape {
        /// Returns the ETag of the new object. The ETag reflects only changes to the contents of an object, not its metadata. The source and destination ETag is identical for a successfully copied non-multipart object.
        public let eTag: String?
        /// Creation date of the object.
        public let lastModified: Date?

        public init(eTag: String? = nil, lastModified: Date? = nil) {
            self.eTag = eTag
            self.lastModified = lastModified
        }

        private enum CodingKeys: String, CodingKey {
            case eTag = "ETag"
            case lastModified = "LastModified"
        }
    }

    public struct CopyPartResult: AWSDecodableShape {
        /// Entity tag of the object.
        public let eTag: String?
        /// Date and time at which the object was uploaded.
        public let lastModified: Date?

        public init(eTag: String? = nil, lastModified: Date? = nil) {
            self.eTag = eTag
            self.lastModified = lastModified
        }

        private enum CodingKeys: String, CodingKey {
            case eTag = "ETag"
            case lastModified = "LastModified"
        }
    }

    public struct CreateBucketConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies the Region where the bucket will be created. If you don't specify a Region, the bucket is created in the US East (N. Virginia) Region (us-east-1).
        public let locationConstraint: BucketLocationConstraint?

        public init(locationConstraint: BucketLocationConstraint? = nil) {
            self.locationConstraint = locationConstraint
        }

        private enum CodingKeys: String, CodingKey {
            case locationConstraint = "LocationConstraint"
        }
    }

    public struct CreateBucketOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "location", location: .header(locationName: "Location"))
        ]

        /// Specifies the Region where the bucket will be created. If you are creating a bucket on the US East (N. Virginia) Region (us-east-1), you do not need to specify the location.
        public let location: String?

        public init(location: String? = nil) {
            self.location = location
        }

        private enum CodingKeys: String, CodingKey {
            case location = "Location"
        }
    }

    public struct CreateBucketRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "createBucketConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "acl", location: .header(locationName: "x-amz-acl")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "createBucketConfiguration", location: .body(locationName: "CreateBucketConfiguration")),
            AWSMemberEncoding(label: "grantFullControl", location: .header(locationName: "x-amz-grant-full-control")),
            AWSMemberEncoding(label: "grantRead", location: .header(locationName: "x-amz-grant-read")),
            AWSMemberEncoding(label: "grantReadACP", location: .header(locationName: "x-amz-grant-read-acp")),
            AWSMemberEncoding(label: "grantWrite", location: .header(locationName: "x-amz-grant-write")),
            AWSMemberEncoding(label: "grantWriteACP", location: .header(locationName: "x-amz-grant-write-acp")),
            AWSMemberEncoding(label: "objectLockEnabledForBucket", location: .header(locationName: "x-amz-bucket-object-lock-enabled"))
        ]

        /// The canned ACL to apply to the bucket.
        public let acl: BucketCannedACL?
        /// The name of the bucket to create.
        public let bucket: String
        /// The configuration information for the bucket.
        public let createBucketConfiguration: CreateBucketConfiguration?
        /// Allows grantee the read, write, read ACP, and write ACP permissions on the bucket.
        public let grantFullControl: String?
        /// Allows grantee to list the objects in the bucket.
        public let grantRead: String?
        /// Allows grantee to read the bucket ACL.
        public let grantReadACP: String?
        /// Allows grantee to create, overwrite, and delete any object in the bucket.
        public let grantWrite: String?
        /// Allows grantee to write the ACL for the applicable bucket.
        public let grantWriteACP: String?
        /// Specifies whether you want S3 Object Lock to be enabled for the new bucket.
        public let objectLockEnabledForBucket: Bool?

        public init(acl: BucketCannedACL? = nil, bucket: String, createBucketConfiguration: CreateBucketConfiguration? = nil, grantFullControl: String? = nil, grantRead: String? = nil, grantReadACP: String? = nil, grantWrite: String? = nil, grantWriteACP: String? = nil, objectLockEnabledForBucket: Bool? = nil) {
            self.acl = acl
            self.bucket = bucket
            self.createBucketConfiguration = createBucketConfiguration
            self.grantFullControl = grantFullControl
            self.grantRead = grantRead
            self.grantReadACP = grantReadACP
            self.grantWrite = grantWrite
            self.grantWriteACP = grantWriteACP
            self.objectLockEnabledForBucket = objectLockEnabledForBucket
        }

        private enum CodingKeys: String, CodingKey {
            case createBucketConfiguration = "CreateBucketConfiguration"
        }
    }

    public struct CreateMultipartUploadOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "abortDate", location: .header(locationName: "x-amz-abort-date")),
            AWSMemberEncoding(label: "abortRuleId", location: .header(locationName: "x-amz-abort-rule-id")),
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSEncryptionContext", location: .header(locationName: "x-amz-server-side-encryption-context")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id"))
        ]

        /// If the bucket has a lifecycle rule configured with an action to abort incomplete multipart uploads and the prefix in the lifecycle rule matches the object name in the request, the response includes this header. The header indicates when the initiated multipart upload becomes eligible for an abort operation. For more information, see  Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Policy. The response also includes the x-amz-abort-rule-id header that provides the ID of the lifecycle configuration rule that defines this action.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var abortDate: Date?
        /// This header is returned along with the x-amz-abort-date header. It identifies the applicable lifecycle configuration rule that defines the action to abort incomplete multipart uploads.
        public let abortRuleId: String?
        /// The name of the bucket to which the multipart upload was initiated.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String?
        /// Indicates whether the multipart upload uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Object key for which the multipart upload was initiated.
        public let key: String?
        public let requestCharged: RequestCharged?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the AWS KMS Encryption Context to use for object encryption. The value of this header is a base64-encoded UTF-8 string holding JSON with the encryption context key-value pairs.
        public let sSEKMSEncryptionContext: String?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?
        /// ID for the initiated multipart upload.
        public let uploadId: String?

        public init(abortDate: Date? = nil, abortRuleId: String? = nil, bucket: String? = nil, bucketKeyEnabled: Bool? = nil, key: String? = nil, requestCharged: RequestCharged? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSEncryptionContext: String? = nil, sSEKMSKeyId: String? = nil, uploadId: String? = nil) {
            self.abortDate = abortDate
            self.abortRuleId = abortRuleId
            self.bucket = bucket
            self.bucketKeyEnabled = bucketKeyEnabled
            self.key = key
            self.requestCharged = requestCharged
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSEncryptionContext = sSEKMSEncryptionContext
            self.sSEKMSKeyId = sSEKMSKeyId
            self.uploadId = uploadId
        }

        private enum CodingKeys: String, CodingKey {
            case abortDate = "x-amz-abort-date"
            case abortRuleId = "x-amz-abort-rule-id"
            case bucket = "Bucket"
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case key = "Key"
            case requestCharged = "x-amz-request-charged"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSEncryptionContext = "x-amz-server-side-encryption-context"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
            case uploadId = "UploadId"
        }
    }

    public struct CreateMultipartUploadRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "acl", location: .header(locationName: "x-amz-acl")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "cacheControl", location: .header(locationName: "Cache-Control")),
            AWSMemberEncoding(label: "contentDisposition", location: .header(locationName: "Content-Disposition")),
            AWSMemberEncoding(label: "contentEncoding", location: .header(locationName: "Content-Encoding")),
            AWSMemberEncoding(label: "contentLanguage", location: .header(locationName: "Content-Language")),
            AWSMemberEncoding(label: "contentType", location: .header(locationName: "Content-Type")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "_expires", location: .header(locationName: "Expires")),
            AWSMemberEncoding(label: "grantFullControl", location: .header(locationName: "x-amz-grant-full-control")),
            AWSMemberEncoding(label: "grantRead", location: .header(locationName: "x-amz-grant-read")),
            AWSMemberEncoding(label: "grantReadACP", location: .header(locationName: "x-amz-grant-read-acp")),
            AWSMemberEncoding(label: "grantWriteACP", location: .header(locationName: "x-amz-grant-write-acp")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "metadata", location: .header(locationName: "x-amz-meta-")),
            AWSMemberEncoding(label: "objectLockLegalHoldStatus", location: .header(locationName: "x-amz-object-lock-legal-hold")),
            AWSMemberEncoding(label: "objectLockMode", location: .header(locationName: "x-amz-object-lock-mode")),
            AWSMemberEncoding(label: "_objectLockRetainUntilDate", location: .header(locationName: "x-amz-object-lock-retain-until-date")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSEncryptionContext", location: .header(locationName: "x-amz-server-side-encryption-context")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "storageClass", location: .header(locationName: "x-amz-storage-class")),
            AWSMemberEncoding(label: "tagging", location: .header(locationName: "x-amz-tagging")),
            AWSMemberEncoding(label: "websiteRedirectLocation", location: .header(locationName: "x-amz-website-redirect-location"))
        ]

        /// The canned ACL to apply to the object. This action is not supported by Amazon S3 on Outposts.
        public let acl: ObjectCannedACL?
        /// The name of the bucket to which to initiate the upload When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption with server-side encryption using AWS KMS (SSE-KMS). Setting this header to true causes Amazon S3 to use an S3 Bucket Key for object encryption with SSE-KMS. Specifying this header with an object operation doesn’t affect bucket-level settings for S3 Bucket Key.
        public let bucketKeyEnabled: Bool?
        /// Specifies caching behavior along the request/reply chain.
        public let cacheControl: String?
        /// Specifies presentational information for the object.
        public let contentDisposition: String?
        /// Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field.
        public let contentEncoding: String?
        /// The language the content is in.
        public let contentLanguage: String?
        /// A standard MIME type describing the format of the object data.
        public let contentType: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The date and time at which the object is no longer cacheable.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var expires: Date?
        /// Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object. This action is not supported by Amazon S3 on Outposts.
        public let grantFullControl: String?
        /// Allows grantee to read the object data and its metadata. This action is not supported by Amazon S3 on Outposts.
        public let grantRead: String?
        /// Allows grantee to read the object ACL. This action is not supported by Amazon S3 on Outposts.
        public let grantReadACP: String?
        /// Allows grantee to write the ACL for the applicable object. This action is not supported by Amazon S3 on Outposts.
        public let grantWriteACP: String?
        /// Object key for which the multipart upload is to be initiated.
        public let key: String
        /// A map of metadata to store with the object in S3.
        public let metadata: [String: String]?
        /// Specifies whether you want to apply a Legal Hold to the uploaded object.
        public let objectLockLegalHoldStatus: ObjectLockLegalHoldStatus?
        /// Specifies the Object Lock mode that you want to apply to the uploaded object.
        public let objectLockMode: ObjectLockMode?
        /// Specifies the date and time when you want the Object Lock to expire.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var objectLockRetainUntilDate: Date?
        public let requestPayer: RequestPayer?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// Specifies the algorithm to use to when encrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This value is used to store the object and then it is discarded; Amazon S3 does not store the encryption key. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// Specifies the AWS KMS Encryption Context to use for object encryption. The value of this header is a base64-encoded UTF-8 string holding JSON with the encryption context key-value pairs.
        public let sSEKMSEncryptionContext: String?
        /// Specifies the ID of the symmetric customer managed AWS KMS CMK to use for object encryption. All GET and PUT requests for an object protected by AWS KMS will fail if not made via SSL or using SigV4. For information about configuring using any of the officially supported AWS SDKs and AWS CLI, see Specifying the Signature Version in Request Authentication in the Amazon S3 Developer Guide.
        public let sSEKMSKeyId: String?
        /// By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. Amazon S3 on Outposts only uses the OUTPOSTS Storage Class. For more information, see Storage Classes in the Amazon S3 Service Developer Guide.
        public let storageClass: StorageClass?
        /// The tag-set for the object. The tag-set must be encoded as URL Query parameters.
        public let tagging: String?
        /// If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.
        public let websiteRedirectLocation: String?

        public init(acl: ObjectCannedACL? = nil, bucket: String, bucketKeyEnabled: Bool? = nil, cacheControl: String? = nil, contentDisposition: String? = nil, contentEncoding: String? = nil, contentLanguage: String? = nil, contentType: String? = nil, expectedBucketOwner: String? = nil, expires: Date? = nil, grantFullControl: String? = nil, grantRead: String? = nil, grantReadACP: String? = nil, grantWriteACP: String? = nil, key: String, metadata: [String: String]? = nil, objectLockLegalHoldStatus: ObjectLockLegalHoldStatus? = nil, objectLockMode: ObjectLockMode? = nil, objectLockRetainUntilDate: Date? = nil, requestPayer: RequestPayer? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSEncryptionContext: String? = nil, sSEKMSKeyId: String? = nil, storageClass: StorageClass? = nil, tagging: String? = nil, websiteRedirectLocation: String? = nil) {
            self.acl = acl
            self.bucket = bucket
            self.bucketKeyEnabled = bucketKeyEnabled
            self.cacheControl = cacheControl
            self.contentDisposition = contentDisposition
            self.contentEncoding = contentEncoding
            self.contentLanguage = contentLanguage
            self.contentType = contentType
            self.expectedBucketOwner = expectedBucketOwner
            self.expires = expires
            self.grantFullControl = grantFullControl
            self.grantRead = grantRead
            self.grantReadACP = grantReadACP
            self.grantWriteACP = grantWriteACP
            self.key = key
            self.metadata = metadata
            self.objectLockLegalHoldStatus = objectLockLegalHoldStatus
            self.objectLockMode = objectLockMode
            self.objectLockRetainUntilDate = objectLockRetainUntilDate
            self.requestPayer = requestPayer
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSEncryptionContext = sSEKMSEncryptionContext
            self.sSEKMSKeyId = sSEKMSKeyId
            self.storageClass = storageClass
            self.tagging = tagging
            self.websiteRedirectLocation = websiteRedirectLocation
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DefaultRetention: AWSEncodableShape & AWSDecodableShape {
        /// The number of days that you want to specify for the default retention period.
        public let days: Int?
        /// The default Object Lock retention mode you want to apply to new objects placed in the specified bucket.
        public let mode: ObjectLockRetentionMode?
        /// The number of years that you want to specify for the default retention period.
        public let years: Int?

        public init(days: Int? = nil, mode: ObjectLockRetentionMode? = nil, years: Int? = nil) {
            self.days = days
            self.mode = mode
            self.years = years
        }

        private enum CodingKeys: String, CodingKey {
            case days = "Days"
            case mode = "Mode"
            case years = "Years"
        }
    }

    public struct Delete: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// The objects to delete.
        public let objects: [ObjectIdentifier]
        /// Element to enable quiet mode for the request. When you add this element, you must set its value to true.
        public let quiet: Bool?

        public init(objects: [ObjectIdentifier], quiet: Bool? = nil) {
            self.objects = objects
            self.quiet = quiet
        }

        public func validate(name: String) throws {
            try self.objects.forEach {
                try $0.validate(name: "\(name).objects[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case objects = "Object"
            case quiet = "Quiet"
        }
    }

    public struct DeleteBucketAnalyticsConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the bucket from which an analytics configuration is deleted.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID that identifies the analytics configuration.
        public let id: String

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketCorsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// Specifies the bucket whose cors configuration is being deleted.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketEncryptionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket containing the server-side encryption configuration to delete.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketIntelligentTieringConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.
        public let bucket: String
        /// The ID used to identify the S3 Intelligent-Tiering configuration.
        public let id: String

        public init(bucket: String, id: String) {
            self.bucket = bucket
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketInventoryConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the bucket containing the inventory configuration to delete.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID used to identify the inventory configuration.
        public let id: String

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketLifecycleRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name of the lifecycle to delete.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketMetricsConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the bucket containing the metrics configuration to delete.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID used to identify the metrics configuration.
        public let id: String

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketOwnershipControlsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The Amazon S3 bucket whose OwnershipControls you want to delete.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketPolicyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketReplicationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        ///  The bucket name.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// Specifies the bucket being deleted.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketTaggingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket that has the tag set to be removed.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteBucketWebsiteRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name for which you want to remove the website configuration.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteMarkerEntry: AWSDecodableShape {
        /// Specifies whether the object is (true) or is not (false) the latest version of an object.
        public let isLatest: Bool?
        /// The object key.
        public let key: String?
        /// Date and time the object was last modified.
        public let lastModified: Date?
        /// The account that created the delete marker.&gt;
        public let owner: Owner?
        /// Version ID of an object.
        public let versionId: String?

        public init(isLatest: Bool? = nil, key: String? = nil, lastModified: Date? = nil, owner: Owner? = nil, versionId: String? = nil) {
            self.isLatest = isLatest
            self.key = key
            self.lastModified = lastModified
            self.owner = owner
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case isLatest = "IsLatest"
            case key = "Key"
            case lastModified = "LastModified"
            case owner = "Owner"
            case versionId = "VersionId"
        }
    }

    public struct DeleteMarkerReplication: AWSEncodableShape & AWSDecodableShape {
        /// Indicates whether to replicate delete markers.  Indicates whether to replicate delete markers.
        public let status: DeleteMarkerReplicationStatus?

        public init(status: DeleteMarkerReplicationStatus? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct DeleteObjectOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "deleteMarker", location: .header(locationName: "x-amz-delete-marker")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]

        /// Specifies whether the versioned object that was permanently deleted was (true) or was not (false) a delete marker.
        public let deleteMarker: Bool?
        public let requestCharged: RequestCharged?
        /// Returns the version ID of the delete marker created as a result of the DELETE operation.
        public let versionId: String?

        public init(deleteMarker: Bool? = nil, requestCharged: RequestCharged? = nil, versionId: String? = nil) {
            self.deleteMarker = deleteMarker
            self.requestCharged = requestCharged
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case deleteMarker = "x-amz-delete-marker"
            case requestCharged = "x-amz-request-charged"
            case versionId = "x-amz-version-id"
        }
    }

    public struct DeleteObjectRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bypassGovernanceRetention", location: .header(locationName: "x-amz-bypass-governance-retention")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "mfa", location: .header(locationName: "x-amz-mfa")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name of the bucket containing the object.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Indicates whether S3 Object Lock should bypass Governance-mode restrictions to process this operation.
        public let bypassGovernanceRetention: Bool?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Key name of the object to delete.
        public let key: String
        /// The concatenation of the authentication device's serial number, a space, and the value that is displayed on your authentication device. Required to permanently delete a versioned object if versioning is configured with MFA delete enabled.
        public let mfa: String?
        public let requestPayer: RequestPayer?
        /// VersionId used to reference a specific version of the object.
        public let versionId: String?

        public init(bucket: String, bypassGovernanceRetention: Bool? = nil, expectedBucketOwner: String? = nil, key: String, mfa: String? = nil, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.bypassGovernanceRetention = bypassGovernanceRetention
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.mfa = mfa
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteObjectTaggingOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]

        /// The versionId of the object the tag-set was removed from.
        public let versionId: String?

        public init(versionId: String? = nil) {
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case versionId = "x-amz-version-id"
        }
    }

    public struct DeleteObjectTaggingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the objects from which to remove the tags.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The key that identifies the object in the bucket from which to remove all tags.
        public let key: String
        /// The versionId of the object that the tag-set will be removed from.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteObjectsOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        /// Container element for a successful delete. It identifies the object that was successfully deleted.
        public let deleted: [DeletedObject]?
        /// Container for a failed delete operation that describes the object that Amazon S3 attempted to delete and the error it encountered.
        public let errors: [Error]?
        public let requestCharged: RequestCharged?

        public init(deleted: [DeletedObject]? = nil, errors: [Error]? = nil, requestCharged: RequestCharged? = nil) {
            self.deleted = deleted
            self.errors = errors
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case deleted = "Deleted"
            case errors = "Error"
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct DeleteObjectsRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "delete"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bypassGovernanceRetention", location: .header(locationName: "x-amz-bypass-governance-retention")),
            AWSMemberEncoding(label: "delete", location: .body(locationName: "Delete")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "mfa", location: .header(locationName: "x-amz-mfa")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer"))
        ]

        /// The bucket name containing the objects to delete.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Specifies whether you want to delete this object even if it has a Governance-type Object Lock in place. You must have sufficient permissions to perform this operation.
        public let bypassGovernanceRetention: Bool?
        /// Container for the request.
        public let delete: Delete
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The concatenation of the authentication device's serial number, a space, and the value that is displayed on your authentication device. Required to permanently delete a versioned object if versioning is configured with MFA delete enabled.
        public let mfa: String?
        public let requestPayer: RequestPayer?

        public init(bucket: String, bypassGovernanceRetention: Bool? = nil, delete: Delete, expectedBucketOwner: String? = nil, mfa: String? = nil, requestPayer: RequestPayer? = nil) {
            self.bucket = bucket
            self.bypassGovernanceRetention = bypassGovernanceRetention
            self.delete = delete
            self.expectedBucketOwner = expectedBucketOwner
            self.mfa = mfa
            self.requestPayer = requestPayer
        }

        public func validate(name: String) throws {
            try self.delete.validate(name: "\(name).delete")
        }

        private enum CodingKeys: String, CodingKey {
            case delete = "Delete"
        }
    }

    public struct DeletePublicAccessBlockRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The Amazon S3 bucket whose PublicAccessBlock configuration you want to delete.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeletedObject: AWSDecodableShape {
        /// Specifies whether the versioned object that was permanently deleted was (true) or was not (false) a delete marker. In a simple DELETE, this header indicates whether (true) or not (false) a delete marker was created.
        public let deleteMarker: Bool?
        /// The version ID of the delete marker created as a result of the DELETE operation. If you delete a specific object version, the value returned by this header is the version ID of the object version deleted.
        public let deleteMarkerVersionId: String?
        /// The name of the deleted object.
        public let key: String?
        /// The version ID of the deleted object.
        public let versionId: String?

        public init(deleteMarker: Bool? = nil, deleteMarkerVersionId: String? = nil, key: String? = nil, versionId: String? = nil) {
            self.deleteMarker = deleteMarker
            self.deleteMarkerVersionId = deleteMarkerVersionId
            self.key = key
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case deleteMarker = "DeleteMarker"
            case deleteMarkerVersionId = "DeleteMarkerVersionId"
            case key = "Key"
            case versionId = "VersionId"
        }
    }

    public struct Destination: AWSEncodableShape & AWSDecodableShape {
        /// Specify this only in a cross-account scenario (where source and destination bucket owners are not the same), and you want to change replica ownership to the AWS account that owns the destination bucket. If this is not specified in the replication configuration, the replicas are owned by same AWS account that owns the source object.
        public let accessControlTranslation: AccessControlTranslation?
        /// Destination bucket owner account ID. In a cross-account scenario, if you direct Amazon S3 to change replica ownership to the AWS account that owns the destination bucket by specifying the AccessControlTranslation property, this is the account ID of the destination bucket owner. For more information, see Replication Additional Configuration: Changing the Replica Owner in the Amazon Simple Storage Service Developer Guide.
        public let account: String?
        ///  The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to store the results.
        public let bucket: String
        /// A container that provides information about encryption. If SourceSelectionCriteria is specified, you must specify this element.
        public let encryptionConfiguration: EncryptionConfiguration?
        ///  A container specifying replication metrics-related settings enabling replication metrics and events.
        public let metrics: Metrics?
        ///  A container specifying S3 Replication Time Control (S3 RTC), including whether S3 RTC is enabled and the time when all objects and operations on objects must be replicated. Must be specified together with a Metrics block.
        public let replicationTime: ReplicationTime?
        ///  The storage class to use when replicating objects, such as S3 Standard or reduced redundancy. By default, Amazon S3 uses the storage class of the source object to create the object replica.  For valid values, see the StorageClass element of the PUT Bucket replication action in the Amazon Simple Storage Service API Reference.
        public let storageClass: StorageClass?

        public init(accessControlTranslation: AccessControlTranslation? = nil, account: String? = nil, bucket: String, encryptionConfiguration: EncryptionConfiguration? = nil, metrics: Metrics? = nil, replicationTime: ReplicationTime? = nil, storageClass: StorageClass? = nil) {
            self.accessControlTranslation = accessControlTranslation
            self.account = account
            self.bucket = bucket
            self.encryptionConfiguration = encryptionConfiguration
            self.metrics = metrics
            self.replicationTime = replicationTime
            self.storageClass = storageClass
        }

        private enum CodingKeys: String, CodingKey {
            case accessControlTranslation = "AccessControlTranslation"
            case account = "Account"
            case bucket = "Bucket"
            case encryptionConfiguration = "EncryptionConfiguration"
            case metrics = "Metrics"
            case replicationTime = "ReplicationTime"
            case storageClass = "StorageClass"
        }
    }

    public struct Encryption: AWSEncodableShape {
        /// The server-side encryption algorithm used when storing job results in Amazon S3 (for example, AES256, aws:kms).
        public let encryptionType: ServerSideEncryption
        /// If the encryption type is aws:kms, this optional value can be used to specify the encryption context for the restore results.
        public let kMSContext: String?
        /// If the encryption type is aws:kms, this optional value specifies the ID of the symmetric customer managed AWS KMS CMK to use for encryption of job results. Amazon S3 only supports symmetric CMKs. For more information, see Using Symmetric and Asymmetric Keys in the AWS Key Management Service Developer Guide.
        public let kMSKeyId: String?

        public init(encryptionType: ServerSideEncryption, kMSContext: String? = nil, kMSKeyId: String? = nil) {
            self.encryptionType = encryptionType
            self.kMSContext = kMSContext
            self.kMSKeyId = kMSKeyId
        }

        private enum CodingKeys: String, CodingKey {
            case encryptionType = "EncryptionType"
            case kMSContext = "KMSContext"
            case kMSKeyId = "KMSKeyId"
        }
    }

    public struct EncryptionConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the ID (Key ARN or Alias ARN) of the customer managed customer master key (CMK) stored in AWS Key Management Service (KMS) for the destination bucket. Amazon S3 uses this key to encrypt replica objects. Amazon S3 only supports symmetric customer managed CMKs. For more information, see Using Symmetric and Asymmetric Keys in the AWS Key Management Service Developer Guide.
        public let replicaKmsKeyID: String?

        public init(replicaKmsKeyID: String? = nil) {
            self.replicaKmsKeyID = replicaKmsKeyID
        }

        private enum CodingKeys: String, CodingKey {
            case replicaKmsKeyID = "ReplicaKmsKeyID"
        }
    }

    public struct EndEvent: AWSDecodableShape {
        public init() {}
    }

    public struct Error: AWSDecodableShape {
        /// The error code is a string that uniquely identifies an error condition. It is meant to be read and understood by programs that detect and handle errors by type.   Amazon S3 error codes       Code: AccessDenied     Description: Access Denied    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: AccountProblem    Description: There is a problem with your AWS account that prevents the operation from completing successfully. Contact AWS Support for further assistance.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: AllAccessDisabled    Description: All access to this Amazon S3 resource has been disabled. Contact AWS Support for further assistance.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: AmbiguousGrantByEmailAddress    Description: The email address you provided is associated with more than one account.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: AuthorizationHeaderMalformed    Description: The authorization header you provided is invalid.    HTTP Status Code: 400 Bad Request    HTTP Status Code: N/A        Code: BadDigest    Description: The Content-MD5 you specified did not match what we received.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: BucketAlreadyExists    Description: The requested bucket name is not available. The bucket namespace is shared by all users of the system. Please select a different name and try again.    HTTP Status Code: 409 Conflict    SOAP Fault Code Prefix: Client        Code: BucketAlreadyOwnedByYou    Description: The bucket you tried to create already exists, and you own it. Amazon S3 returns this error in all AWS Regions except in the North Virginia Region. For legacy compatibility, if you re-create an existing bucket that you already own in the North Virginia Region, Amazon S3 returns 200 OK and resets the bucket access control lists (ACLs).    Code: 409 Conflict (in all Regions except the North Virginia Region)     SOAP Fault Code Prefix: Client        Code: BucketNotEmpty    Description: The bucket you tried to delete is not empty.    HTTP Status Code: 409 Conflict    SOAP Fault Code Prefix: Client        Code: CredentialsNotSupported    Description: This request does not support credentials.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: CrossLocationLoggingProhibited    Description: Cross-location logging not allowed. Buckets in one geographic location cannot log information to a bucket in another location.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: EntityTooSmall    Description: Your proposed upload is smaller than the minimum allowed object size.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: EntityTooLarge    Description: Your proposed upload exceeds the maximum allowed object size.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: ExpiredToken    Description: The provided token has expired.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: IllegalVersioningConfigurationException     Description: Indicates that the versioning configuration specified in the request is invalid.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: IncompleteBody    Description: You did not provide the number of bytes specified by the Content-Length HTTP header    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: IncorrectNumberOfFilesInPostRequest    Description: POST requires exactly one file upload per request.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InlineDataTooLarge    Description: Inline data exceeds the maximum allowed size.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InternalError    Description: We encountered an internal error. Please try again.    HTTP Status Code: 500 Internal Server Error    SOAP Fault Code Prefix: Server        Code: InvalidAccessKeyId    Description: The AWS access key ID you provided does not exist in our records.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: InvalidAddressingHeader    Description: You must specify the Anonymous role.    HTTP Status Code: N/A    SOAP Fault Code Prefix: Client        Code: InvalidArgument    Description: Invalid Argument    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidBucketName    Description: The specified bucket is not valid.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidBucketState    Description: The request is not valid with the current state of the bucket.    HTTP Status Code: 409 Conflict    SOAP Fault Code Prefix: Client        Code: InvalidDigest    Description: The Content-MD5 you specified is not valid.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidEncryptionAlgorithmError    Description: The encryption request you specified is not valid. The valid value is AES256.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidLocationConstraint    Description: The specified location constraint is not valid. For more information about Regions, see How to Select a Region for Your Buckets.     HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidObjectState    Description: The operation is not valid for the current state of the object.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: InvalidPart    Description: One or more of the specified parts could not be found. The part might not have been uploaded, or the specified entity tag might not have matched the part's entity tag.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidPartOrder    Description: The list of parts was not in ascending order. Parts list must be specified in order by part number.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidPayer    Description: All access to this object has been disabled. Please contact AWS Support for further assistance.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: InvalidPolicyDocument    Description: The content of the form does not meet the conditions specified in the policy document.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidRange    Description: The requested range cannot be satisfied.    HTTP Status Code: 416 Requested Range Not Satisfiable    SOAP Fault Code Prefix: Client        Code: InvalidRequest    Description: Please use AWS4-HMAC-SHA256.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: SOAP requests must be made over an HTTPS connection.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidRequest    Description: Amazon S3 Transfer Acceleration is not supported for buckets with non-DNS compliant names.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: Amazon S3 Transfer Acceleration is not supported for buckets with periods (.) in their names.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: Amazon S3 Transfer Accelerate endpoint only supports virtual style requests.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: Amazon S3 Transfer Accelerate is not configured on this bucket.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: Amazon S3 Transfer Accelerate is disabled on this bucket.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: Amazon S3 Transfer Acceleration is not supported on this bucket. Contact AWS Support for more information.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidRequest    Description: Amazon S3 Transfer Acceleration cannot be enabled on this bucket. Contact AWS Support for more information.    HTTP Status Code: 400 Bad Request    Code: N/A        Code: InvalidSecurity    Description: The provided security credentials are not valid.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: InvalidSOAPRequest    Description: The SOAP request body is invalid.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidStorageClass    Description: The storage class you specified is not valid.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidTargetBucketForLogging    Description: The target bucket for logging does not exist, is not owned by you, or does not have the appropriate grants for the log-delivery group.     HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidToken    Description: The provided token is malformed or otherwise invalid.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: InvalidURI    Description: Couldn't parse the specified URI.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: KeyTooLongError    Description: Your key is too long.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MalformedACLError    Description: The XML you provided was not well-formed or did not validate against our published schema.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MalformedPOSTRequest     Description: The body of your POST request is not well-formed multipart/form-data.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MalformedXML    Description: This happens when the user sends malformed XML (XML that doesn't conform to the published XSD) for the configuration. The error message is, "The XML you provided was not well-formed or did not validate against our published schema."     HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MaxMessageLengthExceeded    Description: Your request was too big.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MaxPostPreDataLengthExceededError    Description: Your POST request fields preceding the upload file were too large.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MetadataTooLarge    Description: Your metadata headers exceed the maximum allowed metadata size.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MethodNotAllowed    Description: The specified method is not allowed against this resource.    HTTP Status Code: 405 Method Not Allowed    SOAP Fault Code Prefix: Client        Code: MissingAttachment    Description: A SOAP attachment was expected, but none were found.    HTTP Status Code: N/A    SOAP Fault Code Prefix: Client        Code: MissingContentLength    Description: You must provide the Content-Length HTTP header.    HTTP Status Code: 411 Length Required    SOAP Fault Code Prefix: Client        Code: MissingRequestBodyError    Description: This happens when the user sends an empty XML document as a request. The error message is, "Request body is empty."     HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MissingSecurityElement    Description: The SOAP 1.1 request is missing a security element.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: MissingSecurityHeader    Description: Your request is missing a required header.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: NoLoggingStatusForKey    Description: There is no such thing as a logging status subresource for a key.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: NoSuchBucket    Description: The specified bucket does not exist.    HTTP Status Code: 404 Not Found    SOAP Fault Code Prefix: Client        Code: NoSuchBucketPolicy    Description: The specified bucket does not have a bucket policy.    HTTP Status Code: 404 Not Found    SOAP Fault Code Prefix: Client        Code: NoSuchKey    Description: The specified key does not exist.    HTTP Status Code: 404 Not Found    SOAP Fault Code Prefix: Client        Code: NoSuchLifecycleConfiguration    Description: The lifecycle configuration does not exist.     HTTP Status Code: 404 Not Found    SOAP Fault Code Prefix: Client        Code: NoSuchUpload    Description: The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.    HTTP Status Code: 404 Not Found    SOAP Fault Code Prefix: Client        Code: NoSuchVersion     Description: Indicates that the version ID specified in the request does not match an existing version.    HTTP Status Code: 404 Not Found    SOAP Fault Code Prefix: Client        Code: NotImplemented    Description: A header you provided implies functionality that is not implemented.    HTTP Status Code: 501 Not Implemented    SOAP Fault Code Prefix: Server        Code: NotSignedUp    Description: Your account is not signed up for the Amazon S3 service. You must sign up before you can use Amazon S3. You can sign up at the following URL: https://aws.amazon.com/s3    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: OperationAborted    Description: A conflicting conditional operation is currently in progress against this resource. Try again.    HTTP Status Code: 409 Conflict    SOAP Fault Code Prefix: Client        Code: PermanentRedirect    Description: The bucket you are attempting to access must be addressed using the specified endpoint. Send all future requests to this endpoint.    HTTP Status Code: 301 Moved Permanently    SOAP Fault Code Prefix: Client        Code: PreconditionFailed    Description: At least one of the preconditions you specified did not hold.    HTTP Status Code: 412 Precondition Failed    SOAP Fault Code Prefix: Client        Code: Redirect    Description: Temporary redirect.    HTTP Status Code: 307 Moved Temporarily    SOAP Fault Code Prefix: Client        Code: RestoreAlreadyInProgress    Description: Object restore is already in progress.    HTTP Status Code: 409 Conflict    SOAP Fault Code Prefix: Client        Code: RequestIsNotMultiPartContent    Description: Bucket POST must be of the enclosure-type multipart/form-data.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: RequestTimeout    Description: Your socket connection to the server was not read from or written to within the timeout period.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: RequestTimeTooSkewed    Description: The difference between the request time and the server's time is too large.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: RequestTorrentOfBucketError    Description: Requesting the torrent file of a bucket is not permitted.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: SignatureDoesNotMatch    Description: The request signature we calculated does not match the signature you provided. Check your AWS secret access key and signing method. For more information, see REST Authentication and SOAP Authentication for details.    HTTP Status Code: 403 Forbidden    SOAP Fault Code Prefix: Client        Code: ServiceUnavailable    Description: Reduce your request rate.    HTTP Status Code: 503 Service Unavailable    SOAP Fault Code Prefix: Server        Code: SlowDown    Description: Reduce your request rate.    HTTP Status Code: 503 Slow Down    SOAP Fault Code Prefix: Server        Code: TemporaryRedirect    Description: You are being redirected to the bucket while DNS updates.    HTTP Status Code: 307 Moved Temporarily    SOAP Fault Code Prefix: Client        Code: TokenRefreshRequired    Description: The provided token must be refreshed.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: TooManyBuckets    Description: You have attempted to create more buckets than allowed.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: UnexpectedContent    Description: This request does not support content.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: UnresolvableGrantByEmailAddress    Description: The email address you provided does not match any account on record.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client        Code: UserKeyMustBeSpecified    Description: The bucket POST must contain the specified field name. If it is specified, check the order of the fields.    HTTP Status Code: 400 Bad Request    SOAP Fault Code Prefix: Client
        public let code: String?
        /// The error key.
        public let key: String?
        /// The error message contains a generic description of the error condition in English. It is intended for a human audience. Simple programs display the message directly to the end user if they encounter an error condition they don't know how or don't care to handle. Sophisticated programs with more exhaustive error handling and proper internationalization are more likely to ignore the error message.
        public let message: String?
        /// The version ID of the error.
        public let versionId: String?

        public init(code: String? = nil, key: String? = nil, message: String? = nil, versionId: String? = nil) {
            self.code = code
            self.key = key
            self.message = message
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case code = "Code"
            case key = "Key"
            case message = "Message"
            case versionId = "VersionId"
        }
    }

    public struct ErrorDocument: AWSEncodableShape & AWSDecodableShape {
        /// The object key name to use when a 4XX class error occurs.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let key: String

        public init(key: String) {
            self.key = key
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
        }
    }

    public struct ExistingObjectReplication: AWSEncodableShape & AWSDecodableShape {
        public let status: ExistingObjectReplicationStatus

        public init(status: ExistingObjectReplicationStatus) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct FilterRule: AWSEncodableShape & AWSDecodableShape {
        /// The object key name prefix or suffix identifying one or more objects to which the filtering rule applies. The maximum length is 1,024 characters. Overlapping prefixes and suffixes are not supported. For more information, see Configuring Event Notifications in the Amazon Simple Storage Service Developer Guide.
        public let name: FilterRuleName?
        /// The value that the filter searches for in object key names.
        public let value: String?

        public init(name: FilterRuleName? = nil, value: String? = nil) {
            self.name = name
            self.value = value
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case value = "Value"
        }
    }

    public struct GetBucketAccelerateConfigurationOutput: AWSDecodableShape {
        /// The accelerate configuration of the bucket.
        public let status: BucketAccelerateStatus?

        public init(status: BucketAccelerateStatus? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct GetBucketAccelerateConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which the accelerate configuration is retrieved.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketAclOutput: AWSDecodableShape {
        public struct _GrantsEncoding: ArrayCoderProperties { public static let member = "Grant" }

        /// A list of grants.
        @OptionalCustomCoding<ArrayCoder<_GrantsEncoding, Grant>>
        public var grants: [Grant]?
        /// Container for the bucket owner's display name and ID.
        public let owner: Owner?

        public init(grants: [Grant]? = nil, owner: Owner? = nil) {
            self.grants = grants
            self.owner = owner
        }

        private enum CodingKeys: String, CodingKey {
            case grants = "AccessControlList"
            case owner = "Owner"
        }
    }

    public struct GetBucketAclRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// Specifies the S3 bucket whose ACL is being requested.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketAnalyticsConfigurationOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "analyticsConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "analyticsConfiguration", location: .body(locationName: "AnalyticsConfiguration"))
        ]

        /// The configuration and any analyses for the analytics filter.
        public let analyticsConfiguration: AnalyticsConfiguration?

        public init(analyticsConfiguration: AnalyticsConfiguration? = nil) {
            self.analyticsConfiguration = analyticsConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case analyticsConfiguration = "AnalyticsConfiguration"
        }
    }

    public struct GetBucketAnalyticsConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the bucket from which an analytics configuration is retrieved.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID that identifies the analytics configuration.
        public let id: String

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketCorsOutput: AWSDecodableShape {
        /// A set of origins and methods (cross-origin access that you want to allow). You can add up to 100 rules to the configuration.
        public let cORSRules: [CORSRule]?

        public init(cORSRules: [CORSRule]? = nil) {
            self.cORSRules = cORSRules
        }

        private enum CodingKeys: String, CodingKey {
            case cORSRules = "CORSRule"
        }
    }

    public struct GetBucketCorsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name for which to get the cors configuration.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketEncryptionOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "serverSideEncryptionConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "serverSideEncryptionConfiguration", location: .body(locationName: "ServerSideEncryptionConfiguration"))
        ]

        public let serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration?

        public init(serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration? = nil) {
            self.serverSideEncryptionConfiguration = serverSideEncryptionConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case serverSideEncryptionConfiguration = "ServerSideEncryptionConfiguration"
        }
    }

    public struct GetBucketEncryptionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket from which the server-side encryption configuration is retrieved.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketIntelligentTieringConfigurationOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "intelligentTieringConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "intelligentTieringConfiguration", location: .body(locationName: "IntelligentTieringConfiguration"))
        ]

        /// Container for S3 Intelligent-Tiering configuration.
        public let intelligentTieringConfiguration: IntelligentTieringConfiguration?

        public init(intelligentTieringConfiguration: IntelligentTieringConfiguration? = nil) {
            self.intelligentTieringConfiguration = intelligentTieringConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case intelligentTieringConfiguration = "IntelligentTieringConfiguration"
        }
    }

    public struct GetBucketIntelligentTieringConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.
        public let bucket: String
        /// The ID used to identify the S3 Intelligent-Tiering configuration.
        public let id: String

        public init(bucket: String, id: String) {
            self.bucket = bucket
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketInventoryConfigurationOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "inventoryConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "inventoryConfiguration", location: .body(locationName: "InventoryConfiguration"))
        ]

        /// Specifies the inventory configuration.
        public let inventoryConfiguration: InventoryConfiguration?

        public init(inventoryConfiguration: InventoryConfiguration? = nil) {
            self.inventoryConfiguration = inventoryConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case inventoryConfiguration = "InventoryConfiguration"
        }
    }

    public struct GetBucketInventoryConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the bucket containing the inventory configuration to retrieve.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID used to identify the inventory configuration.
        public let id: String

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketLifecycleConfigurationOutput: AWSDecodableShape {
        /// Container for a lifecycle rule.
        public let rules: [LifecycleRule]?

        public init(rules: [LifecycleRule]? = nil) {
            self.rules = rules
        }

        private enum CodingKeys: String, CodingKey {
            case rules = "Rule"
        }
    }

    public struct GetBucketLifecycleConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the lifecycle information.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketLifecycleOutput: AWSDecodableShape {
        /// Container for a lifecycle rule.
        public let rules: [Rule]?

        public init(rules: [Rule]? = nil) {
            self.rules = rules
        }

        private enum CodingKeys: String, CodingKey {
            case rules = "Rule"
        }
    }

    public struct GetBucketLifecycleRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the lifecycle information.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketLocationOutput: AWSDecodableShape {
        /// Specifies the Region where the bucket resides. For a list of all the Amazon S3 supported location constraints by Region, see Regions and Endpoints. Buckets in Region us-east-1 have a LocationConstraint of null.
        public let locationConstraint: BucketLocationConstraint?

        public init(locationConstraint: BucketLocationConstraint? = nil) {
            self.locationConstraint = locationConstraint
        }

        private enum CodingKeys: String, CodingKey {
            case locationConstraint = "LocationConstraint"
        }
    }

    public struct GetBucketLocationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the location.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketLoggingOutput: AWSDecodableShape {
        public let loggingEnabled: LoggingEnabled?

        public init(loggingEnabled: LoggingEnabled? = nil) {
            self.loggingEnabled = loggingEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case loggingEnabled = "LoggingEnabled"
        }
    }

    public struct GetBucketLoggingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name for which to get the logging information.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketMetricsConfigurationOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "metricsConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "metricsConfiguration", location: .body(locationName: "MetricsConfiguration"))
        ]

        /// Specifies the metrics configuration.
        public let metricsConfiguration: MetricsConfiguration?

        public init(metricsConfiguration: MetricsConfiguration? = nil) {
            self.metricsConfiguration = metricsConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case metricsConfiguration = "MetricsConfiguration"
        }
    }

    public struct GetBucketMetricsConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The name of the bucket containing the metrics configuration to retrieve.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID used to identify the metrics configuration.
        public let id: String

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketNotificationConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the notification configuration.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketOwnershipControlsOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "ownershipControls"
        public static var _encoding = [
            AWSMemberEncoding(label: "ownershipControls", location: .body(locationName: "OwnershipControls"))
        ]

        /// The OwnershipControls (BucketOwnerPreferred or ObjectWriter) currently in effect for this Amazon S3 bucket.
        public let ownershipControls: OwnershipControls?

        public init(ownershipControls: OwnershipControls? = nil) {
            self.ownershipControls = ownershipControls
        }

        private enum CodingKeys: String, CodingKey {
            case ownershipControls = "OwnershipControls"
        }
    }

    public struct GetBucketOwnershipControlsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the Amazon S3 bucket whose OwnershipControls you want to retrieve.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketPolicyOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "policy"
        public static var _encoding = [
            AWSMemberEncoding(label: "policy", location: .body(locationName: "Policy"))
        ]

        /// The bucket policy as a JSON document.
        public let policy: String?

        public init(policy: String? = nil) {
            self.policy = policy
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
        }
    }

    public struct GetBucketPolicyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name for which to get the bucket policy.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketPolicyStatusOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "policyStatus"
        public static var _encoding = [
            AWSMemberEncoding(label: "policyStatus", location: .body(locationName: "PolicyStatus"))
        ]

        /// The policy status for the specified bucket.
        public let policyStatus: PolicyStatus?

        public init(policyStatus: PolicyStatus? = nil) {
            self.policyStatus = policyStatus
        }

        private enum CodingKeys: String, CodingKey {
            case policyStatus = "PolicyStatus"
        }
    }

    public struct GetBucketPolicyStatusRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the Amazon S3 bucket whose policy status you want to retrieve.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketReplicationOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "replicationConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "replicationConfiguration", location: .body(locationName: "ReplicationConfiguration"))
        ]

        public let replicationConfiguration: ReplicationConfiguration?

        public init(replicationConfiguration: ReplicationConfiguration? = nil) {
            self.replicationConfiguration = replicationConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case replicationConfiguration = "ReplicationConfiguration"
        }
    }

    public struct GetBucketReplicationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name for which to get the replication information.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketRequestPaymentOutput: AWSDecodableShape {
        /// Specifies who pays for the download and request fees.
        public let payer: Payer?

        public init(payer: Payer? = nil) {
            self.payer = payer
        }

        private enum CodingKeys: String, CodingKey {
            case payer = "Payer"
        }
    }

    public struct GetBucketRequestPaymentRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the payment request configuration
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketTaggingOutput: AWSDecodableShape {
        public struct _TagSetEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// Contains the tag set.
        @CustomCoding<ArrayCoder<_TagSetEncoding, Tag>>
        public var tagSet: [Tag]

        public init(tagSet: [Tag]) {
            self.tagSet = tagSet
        }

        private enum CodingKeys: String, CodingKey {
            case tagSet = "TagSet"
        }
    }

    public struct GetBucketTaggingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the tagging information.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketVersioningOutput: AWSDecodableShape {
        /// Specifies whether MFA delete is enabled in the bucket versioning configuration. This element is only returned if the bucket has been configured with MFA delete. If the bucket has never been so configured, this element is not returned.
        public let mFADelete: MFADeleteStatus?
        /// The versioning state of the bucket.
        public let status: BucketVersioningStatus?

        public init(mFADelete: MFADeleteStatus? = nil, status: BucketVersioningStatus? = nil) {
            self.mFADelete = mFADelete
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case mFADelete = "MfaDelete"
            case status = "Status"
        }
    }

    public struct GetBucketVersioningRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to get the versioning information.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBucketWebsiteOutput: AWSDecodableShape {
        public struct _RoutingRulesEncoding: ArrayCoderProperties { public static let member = "RoutingRule" }

        /// The object key name of the website error document to use for 4XX class errors.
        public let errorDocument: ErrorDocument?
        /// The name of the index document for the website (for example index.html).
        public let indexDocument: IndexDocument?
        /// Specifies the redirect behavior of all requests to a website endpoint of an Amazon S3 bucket.
        public let redirectAllRequestsTo: RedirectAllRequestsTo?
        /// Rules that define when a redirect is applied and the redirect behavior.
        @OptionalCustomCoding<ArrayCoder<_RoutingRulesEncoding, RoutingRule>>
        public var routingRules: [RoutingRule]?

        public init(errorDocument: ErrorDocument? = nil, indexDocument: IndexDocument? = nil, redirectAllRequestsTo: RedirectAllRequestsTo? = nil, routingRules: [RoutingRule]? = nil) {
            self.errorDocument = errorDocument
            self.indexDocument = indexDocument
            self.redirectAllRequestsTo = redirectAllRequestsTo
            self.routingRules = routingRules
        }

        private enum CodingKeys: String, CodingKey {
            case errorDocument = "ErrorDocument"
            case indexDocument = "IndexDocument"
            case redirectAllRequestsTo = "RedirectAllRequestsTo"
            case routingRules = "RoutingRules"
        }
    }

    public struct GetBucketWebsiteRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name for which to get the website configuration.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectAclOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]
        public struct _GrantsEncoding: ArrayCoderProperties { public static let member = "Grant" }

        /// A list of grants.
        @OptionalCustomCoding<ArrayCoder<_GrantsEncoding, Grant>>
        public var grants: [Grant]?
        ///  Container for the bucket owner's display name and ID.
        public let owner: Owner?
        public let requestCharged: RequestCharged?

        public init(grants: [Grant]? = nil, owner: Owner? = nil, requestCharged: RequestCharged? = nil) {
            self.grants = grants
            self.owner = owner
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case grants = "AccessControlList"
            case owner = "Owner"
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct GetObjectAclRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name that contains the object for which to get the ACL information.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The key of the object for which to get the ACL information.
        public let key: String
        public let requestPayer: RequestPayer?
        /// VersionId used to reference a specific version of the object.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectLegalHoldOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "legalHold"
        public static var _encoding = [
            AWSMemberEncoding(label: "legalHold", location: .body(locationName: "LegalHold"))
        ]

        /// The current Legal Hold status for the specified object.
        public let legalHold: ObjectLockLegalHold?

        public init(legalHold: ObjectLockLegalHold? = nil) {
            self.legalHold = legalHold
        }

        private enum CodingKeys: String, CodingKey {
            case legalHold = "LegalHold"
        }
    }

    public struct GetObjectLegalHoldRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object whose Legal Hold status you want to retrieve.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The key name for the object whose Legal Hold status you want to retrieve.
        public let key: String
        public let requestPayer: RequestPayer?
        /// The version ID of the object whose Legal Hold status you want to retrieve.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectLockConfigurationOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "objectLockConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "objectLockConfiguration", location: .body(locationName: "ObjectLockConfiguration"))
        ]

        /// The specified bucket's Object Lock configuration.
        public let objectLockConfiguration: ObjectLockConfiguration?

        public init(objectLockConfiguration: ObjectLockConfiguration? = nil) {
            self.objectLockConfiguration = objectLockConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case objectLockConfiguration = "ObjectLockConfiguration"
        }
    }

    public struct GetObjectLockConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket whose Object Lock configuration you want to retrieve. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "body"
        public static let _payloadOptions: AWSShapePayloadOptions = [.raw, .allowStreaming]
        public static var _encoding = [
            AWSMemberEncoding(label: "acceptRanges", location: .header(locationName: "accept-ranges")),
            AWSMemberEncoding(label: "body", location: .body(locationName: "Body")),
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "cacheControl", location: .header(locationName: "Cache-Control")),
            AWSMemberEncoding(label: "contentDisposition", location: .header(locationName: "Content-Disposition")),
            AWSMemberEncoding(label: "contentEncoding", location: .header(locationName: "Content-Encoding")),
            AWSMemberEncoding(label: "contentLanguage", location: .header(locationName: "Content-Language")),
            AWSMemberEncoding(label: "contentLength", location: .header(locationName: "Content-Length")),
            AWSMemberEncoding(label: "contentRange", location: .header(locationName: "Content-Range")),
            AWSMemberEncoding(label: "contentType", location: .header(locationName: "Content-Type")),
            AWSMemberEncoding(label: "deleteMarker", location: .header(locationName: "x-amz-delete-marker")),
            AWSMemberEncoding(label: "eTag", location: .header(locationName: "ETag")),
            AWSMemberEncoding(label: "expiration", location: .header(locationName: "x-amz-expiration")),
            AWSMemberEncoding(label: "expires", location: .header(locationName: "Expires")),
            AWSMemberEncoding(label: "lastModified", location: .header(locationName: "Last-Modified")),
            AWSMemberEncoding(label: "metadata", location: .header(locationName: "x-amz-meta-")),
            AWSMemberEncoding(label: "missingMeta", location: .header(locationName: "x-amz-missing-meta")),
            AWSMemberEncoding(label: "objectLockLegalHoldStatus", location: .header(locationName: "x-amz-object-lock-legal-hold")),
            AWSMemberEncoding(label: "objectLockMode", location: .header(locationName: "x-amz-object-lock-mode")),
            AWSMemberEncoding(label: "objectLockRetainUntilDate", location: .header(locationName: "x-amz-object-lock-retain-until-date")),
            AWSMemberEncoding(label: "partsCount", location: .header(locationName: "x-amz-mp-parts-count")),
            AWSMemberEncoding(label: "replicationStatus", location: .header(locationName: "x-amz-replication-status")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "restore", location: .header(locationName: "x-amz-restore")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "storageClass", location: .header(locationName: "x-amz-storage-class")),
            AWSMemberEncoding(label: "tagCount", location: .header(locationName: "x-amz-tagging-count")),
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id")),
            AWSMemberEncoding(label: "websiteRedirectLocation", location: .header(locationName: "x-amz-website-redirect-location"))
        ]

        /// Indicates that a range of bytes was specified.
        public let acceptRanges: String?
        /// Object data.
        public let body: AWSPayload?
        /// Indicates whether the object uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Specifies caching behavior along the request/reply chain.
        public let cacheControl: String?
        /// Specifies presentational information for the object.
        public let contentDisposition: String?
        /// Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field.
        public let contentEncoding: String?
        /// The language the content is in.
        public let contentLanguage: String?
        /// Size of the body in bytes.
        public let contentLength: Int64?
        /// The portion of the object returned in the response.
        public let contentRange: String?
        /// A standard MIME type describing the format of the object data.
        public let contentType: String?
        /// Specifies whether the object retrieved was (true) or was not (false) a Delete Marker. If false, this response header does not appear in the response.
        public let deleteMarker: Bool?
        /// An ETag is an opaque identifier assigned by a web server to a specific version of a resource found at a URL.
        public let eTag: String?
        /// If the object expiration is configured (see PUT Bucket lifecycle), the response includes this header. It includes the expiry-date and rule-id key-value pairs providing object expiration information. The value of the rule-id is URL encoded.
        public let expiration: String?
        /// The date and time at which the object is no longer cacheable.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var expires: Date?
        /// Creation date of the object.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var lastModified: Date?
        /// A map of metadata to store with the object in S3.
        public let metadata: [String: String]?
        /// This is set to the number of metadata entries not returned in x-amz-meta headers. This can happen if you create metadata using an API like SOAP that supports more flexible metadata than the REST API. For example, using SOAP, you can create metadata whose values are not legal HTTP headers.
        public let missingMeta: Int?
        /// Indicates whether this object has an active legal hold. This field is only returned if you have permission to view an object's legal hold status.
        public let objectLockLegalHoldStatus: ObjectLockLegalHoldStatus?
        /// The Object Lock mode currently in place for this object.
        public let objectLockMode: ObjectLockMode?
        /// The date and time when this object's Object Lock will expire.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var objectLockRetainUntilDate: Date?
        /// The count of parts this object has.
        public let partsCount: Int?
        /// Amazon S3 can return this if your request involves a bucket that is either a source or destination in a replication rule.
        public let replicationStatus: ReplicationStatus?
        public let requestCharged: RequestCharged?
        /// Provides information about object restoration operation and expiration time of the restored object copy.
        public let restore: String?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?
        /// Provides storage class information of the object. Amazon S3 returns this header for all objects except for S3 Standard storage class objects.
        public let storageClass: StorageClass?
        /// The number of tags, if any, on the object.
        public let tagCount: Int?
        /// Version of the object.
        public let versionId: String?
        /// If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.
        public let websiteRedirectLocation: String?

        public init(acceptRanges: String? = nil, body: AWSPayload? = nil, bucketKeyEnabled: Bool? = nil, cacheControl: String? = nil, contentDisposition: String? = nil, contentEncoding: String? = nil, contentLanguage: String? = nil, contentLength: Int64? = nil, contentRange: String? = nil, contentType: String? = nil, deleteMarker: Bool? = nil, eTag: String? = nil, expiration: String? = nil, expires: Date? = nil, lastModified: Date? = nil, metadata: [String: String]? = nil, missingMeta: Int? = nil, objectLockLegalHoldStatus: ObjectLockLegalHoldStatus? = nil, objectLockMode: ObjectLockMode? = nil, objectLockRetainUntilDate: Date? = nil, partsCount: Int? = nil, replicationStatus: ReplicationStatus? = nil, requestCharged: RequestCharged? = nil, restore: String? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSKeyId: String? = nil, storageClass: StorageClass? = nil, tagCount: Int? = nil, versionId: String? = nil, websiteRedirectLocation: String? = nil) {
            self.acceptRanges = acceptRanges
            self.body = body
            self.bucketKeyEnabled = bucketKeyEnabled
            self.cacheControl = cacheControl
            self.contentDisposition = contentDisposition
            self.contentEncoding = contentEncoding
            self.contentLanguage = contentLanguage
            self.contentLength = contentLength
            self.contentRange = contentRange
            self.contentType = contentType
            self.deleteMarker = deleteMarker
            self.eTag = eTag
            self.expiration = expiration
            self.expires = expires
            self.lastModified = lastModified
            self.metadata = metadata
            self.missingMeta = missingMeta
            self.objectLockLegalHoldStatus = objectLockLegalHoldStatus
            self.objectLockMode = objectLockMode
            self.objectLockRetainUntilDate = objectLockRetainUntilDate
            self.partsCount = partsCount
            self.replicationStatus = replicationStatus
            self.requestCharged = requestCharged
            self.restore = restore
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSKeyId = sSEKMSKeyId
            self.storageClass = storageClass
            self.tagCount = tagCount
            self.versionId = versionId
            self.websiteRedirectLocation = websiteRedirectLocation
        }

        private enum CodingKeys: String, CodingKey {
            case acceptRanges = "accept-ranges"
            case body = "Body"
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case cacheControl = "Cache-Control"
            case contentDisposition = "Content-Disposition"
            case contentEncoding = "Content-Encoding"
            case contentLanguage = "Content-Language"
            case contentLength = "Content-Length"
            case contentRange = "Content-Range"
            case contentType = "Content-Type"
            case deleteMarker = "x-amz-delete-marker"
            case eTag = "ETag"
            case expiration = "x-amz-expiration"
            case expires = "Expires"
            case lastModified = "Last-Modified"
            case metadata = "x-amz-meta-"
            case missingMeta = "x-amz-missing-meta"
            case objectLockLegalHoldStatus = "x-amz-object-lock-legal-hold"
            case objectLockMode = "x-amz-object-lock-mode"
            case objectLockRetainUntilDate = "x-amz-object-lock-retain-until-date"
            case partsCount = "x-amz-mp-parts-count"
            case replicationStatus = "x-amz-replication-status"
            case requestCharged = "x-amz-request-charged"
            case restore = "x-amz-restore"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
            case storageClass = "x-amz-storage-class"
            case tagCount = "x-amz-tagging-count"
            case versionId = "x-amz-version-id"
            case websiteRedirectLocation = "x-amz-website-redirect-location"
        }
    }

    public struct GetObjectRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "ifMatch", location: .header(locationName: "If-Match")),
            AWSMemberEncoding(label: "_ifModifiedSince", location: .header(locationName: "If-Modified-Since")),
            AWSMemberEncoding(label: "ifNoneMatch", location: .header(locationName: "If-None-Match")),
            AWSMemberEncoding(label: "_ifUnmodifiedSince", location: .header(locationName: "If-Unmodified-Since")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "partNumber", location: .querystring(locationName: "partNumber")),
            AWSMemberEncoding(label: "range", location: .header(locationName: "Range")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "responseCacheControl", location: .querystring(locationName: "response-cache-control")),
            AWSMemberEncoding(label: "responseContentDisposition", location: .querystring(locationName: "response-content-disposition")),
            AWSMemberEncoding(label: "responseContentEncoding", location: .querystring(locationName: "response-content-encoding")),
            AWSMemberEncoding(label: "responseContentLanguage", location: .querystring(locationName: "response-content-language")),
            AWSMemberEncoding(label: "responseContentType", location: .querystring(locationName: "response-content-type")),
            AWSMemberEncoding(label: "_responseExpires", location: .querystring(locationName: "response-expires")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Return the object only if its entity tag (ETag) is the same as the one specified, otherwise return a 412 (precondition failed).
        public let ifMatch: String?
        /// Return the object only if it has been modified since the specified time, otherwise return a 304 (not modified).
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var ifModifiedSince: Date?
        /// Return the object only if its entity tag (ETag) is different from the one specified, otherwise return a 304 (not modified).
        public let ifNoneMatch: String?
        /// Return the object only if it has not been modified since the specified time, otherwise return a 412 (precondition failed).
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var ifUnmodifiedSince: Date?
        /// Key of the object to get.
        public let key: String
        /// Part number of the object being read. This is a positive integer between 1 and 10,000. Effectively performs a 'ranged' GET request for the part specified. Useful for downloading just a part of an object.
        public let partNumber: Int?
        /// Downloads the specified range bytes of an object. For more information about the HTTP Range header, see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.  Amazon S3 doesn't support retrieving multiple ranges of data per GET request.
        public let range: String?
        public let requestPayer: RequestPayer?
        /// Sets the Cache-Control header of the response.
        public let responseCacheControl: String?
        /// Sets the Content-Disposition header of the response
        public let responseContentDisposition: String?
        /// Sets the Content-Encoding header of the response.
        public let responseContentEncoding: String?
        /// Sets the Content-Language header of the response.
        public let responseContentLanguage: String?
        /// Sets the Content-Type header of the response.
        public let responseContentType: String?
        /// Sets the Expires header of the response.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var responseExpires: Date?
        /// Specifies the algorithm to use to when decrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 used to encrypt the data. This value is used to decrypt the object when recovering it and must match the one used when storing the data. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// VersionId used to reference a specific version of the object.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, ifMatch: String? = nil, ifModifiedSince: Date? = nil, ifNoneMatch: String? = nil, ifUnmodifiedSince: Date? = nil, key: String, partNumber: Int? = nil, range: String? = nil, requestPayer: RequestPayer? = nil, responseCacheControl: String? = nil, responseContentDisposition: String? = nil, responseContentEncoding: String? = nil, responseContentLanguage: String? = nil, responseContentType: String? = nil, responseExpires: Date? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.ifMatch = ifMatch
            self.ifModifiedSince = ifModifiedSince
            self.ifNoneMatch = ifNoneMatch
            self.ifUnmodifiedSince = ifUnmodifiedSince
            self.key = key
            self.partNumber = partNumber
            self.range = range
            self.requestPayer = requestPayer
            self.responseCacheControl = responseCacheControl
            self.responseContentDisposition = responseContentDisposition
            self.responseContentEncoding = responseContentEncoding
            self.responseContentLanguage = responseContentLanguage
            self.responseContentType = responseContentType
            self.responseExpires = responseExpires
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectRetentionOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "retention"
        public static var _encoding = [
            AWSMemberEncoding(label: "retention", location: .body(locationName: "Retention"))
        ]

        /// The container element for an object's retention settings.
        public let retention: ObjectLockRetention?

        public init(retention: ObjectLockRetention? = nil) {
            self.retention = retention
        }

        private enum CodingKeys: String, CodingKey {
            case retention = "Retention"
        }
    }

    public struct GetObjectRetentionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object whose retention settings you want to retrieve.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The key name for the object whose retention settings you want to retrieve.
        public let key: String
        public let requestPayer: RequestPayer?
        /// The version ID for the object whose retention settings you want to retrieve.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectTaggingOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]
        public struct _TagSetEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// Contains the tag set.
        @CustomCoding<ArrayCoder<_TagSetEncoding, Tag>>
        public var tagSet: [Tag]
        /// The versionId of the object for which you got the tagging information.
        public let versionId: String?

        public init(tagSet: [Tag], versionId: String? = nil) {
            self.tagSet = tagSet
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case tagSet = "TagSet"
            case versionId = "x-amz-version-id"
        }
    }

    public struct GetObjectTaggingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object for which to get the tagging information.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Object key for which to get the tagging information.
        public let key: String
        public let requestPayer: RequestPayer?
        /// The versionId of the object for which to get the tagging information.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetObjectTorrentOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "body"
        public static let _payloadOptions: AWSShapePayloadOptions = [.raw, .allowStreaming]
        public static var _encoding = [
            AWSMemberEncoding(label: "body", location: .body(locationName: "Body")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        /// A Bencoded dictionary as defined by the BitTorrent specification
        public let body: AWSPayload?
        public let requestCharged: RequestCharged?

        public init(body: AWSPayload? = nil, requestCharged: RequestCharged? = nil) {
            self.body = body
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case body = "Body"
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct GetObjectTorrentRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer"))
        ]

        /// The name of the bucket containing the object for which to get the torrent files.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The object key for which to get the information.
        public let key: String
        public let requestPayer: RequestPayer?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetPublicAccessBlockOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "publicAccessBlockConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "publicAccessBlockConfiguration", location: .body(locationName: "PublicAccessBlockConfiguration"))
        ]

        /// The PublicAccessBlock configuration currently in effect for this Amazon S3 bucket.
        public let publicAccessBlockConfiguration: PublicAccessBlockConfiguration?

        public init(publicAccessBlockConfiguration: PublicAccessBlockConfiguration? = nil) {
            self.publicAccessBlockConfiguration = publicAccessBlockConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case publicAccessBlockConfiguration = "PublicAccessBlockConfiguration"
        }
    }

    public struct GetPublicAccessBlockRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the Amazon S3 bucket whose PublicAccessBlock configuration you want to retrieve.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GlacierJobParameters: AWSEncodableShape {
        /// Retrieval tier at which the restore will be processed.
        public let tier: Tier

        public init(tier: Tier) {
            self.tier = tier
        }

        private enum CodingKeys: String, CodingKey {
            case tier = "Tier"
        }
    }

    public struct Grant: AWSEncodableShape & AWSDecodableShape {
        /// The person being granted permissions.
        public let grantee: Grantee?
        /// Specifies the permission given to the grantee.
        public let permission: Permission?

        public init(grantee: Grantee? = nil, permission: Permission? = nil) {
            self.grantee = grantee
            self.permission = permission
        }

        private enum CodingKeys: String, CodingKey {
            case grantee = "Grantee"
            case permission = "Permission"
        }
    }

    public struct Grantee: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://www.w3.org/2001/XMLSchema-instance"

        /// Screen name of the grantee.
        public let displayName: String?
        /// Email address of the grantee.  Using email addresses to specify a grantee is only supported in the following AWS Regions:    US East (N. Virginia)   US West (N. California)    US West (Oregon)    Asia Pacific (Singapore)   Asia Pacific (Sydney)   Asia Pacific (Tokyo)   Europe (Ireland)   South America (São Paulo)   For a list of all the Amazon S3 supported Regions and endpoints, see Regions and Endpoints in the AWS General Reference.
        public let emailAddress: String?
        /// The canonical user ID of the grantee.
        public let id: String?
        /// Type of grantee
        public let type: `Type`
        /// URI of the grantee group.
        public let uri: String?

        public init(displayName: String? = nil, emailAddress: String? = nil, id: String? = nil, type: `Type`, uri: String? = nil) {
            self.displayName = displayName
            self.emailAddress = emailAddress
            self.id = id
            self.type = type
            self.uri = uri
        }

        private enum CodingKeys: String, CodingKey {
            case displayName = "DisplayName"
            case emailAddress = "EmailAddress"
            case id = "ID"
            case type = "xsi:type"
            case uri = "URI"
        }
    }

    public struct HeadBucketRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The bucket name. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct HeadObjectOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "acceptRanges", location: .header(locationName: "accept-ranges")),
            AWSMemberEncoding(label: "archiveStatus", location: .header(locationName: "x-amz-archive-status")),
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "cacheControl", location: .header(locationName: "Cache-Control")),
            AWSMemberEncoding(label: "contentDisposition", location: .header(locationName: "Content-Disposition")),
            AWSMemberEncoding(label: "contentEncoding", location: .header(locationName: "Content-Encoding")),
            AWSMemberEncoding(label: "contentLanguage", location: .header(locationName: "Content-Language")),
            AWSMemberEncoding(label: "contentLength", location: .header(locationName: "Content-Length")),
            AWSMemberEncoding(label: "contentType", location: .header(locationName: "Content-Type")),
            AWSMemberEncoding(label: "deleteMarker", location: .header(locationName: "x-amz-delete-marker")),
            AWSMemberEncoding(label: "eTag", location: .header(locationName: "ETag")),
            AWSMemberEncoding(label: "expiration", location: .header(locationName: "x-amz-expiration")),
            AWSMemberEncoding(label: "expires", location: .header(locationName: "Expires")),
            AWSMemberEncoding(label: "lastModified", location: .header(locationName: "Last-Modified")),
            AWSMemberEncoding(label: "metadata", location: .header(locationName: "x-amz-meta-")),
            AWSMemberEncoding(label: "missingMeta", location: .header(locationName: "x-amz-missing-meta")),
            AWSMemberEncoding(label: "objectLockLegalHoldStatus", location: .header(locationName: "x-amz-object-lock-legal-hold")),
            AWSMemberEncoding(label: "objectLockMode", location: .header(locationName: "x-amz-object-lock-mode")),
            AWSMemberEncoding(label: "objectLockRetainUntilDate", location: .header(locationName: "x-amz-object-lock-retain-until-date")),
            AWSMemberEncoding(label: "partsCount", location: .header(locationName: "x-amz-mp-parts-count")),
            AWSMemberEncoding(label: "replicationStatus", location: .header(locationName: "x-amz-replication-status")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "restore", location: .header(locationName: "x-amz-restore")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "storageClass", location: .header(locationName: "x-amz-storage-class")),
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id")),
            AWSMemberEncoding(label: "websiteRedirectLocation", location: .header(locationName: "x-amz-website-redirect-location"))
        ]

        /// Indicates that a range of bytes was specified.
        public let acceptRanges: String?
        /// The archive state of the head object.
        public let archiveStatus: ArchiveStatus?
        /// Indicates whether the object uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Specifies caching behavior along the request/reply chain.
        public let cacheControl: String?
        /// Specifies presentational information for the object.
        public let contentDisposition: String?
        /// Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field.
        public let contentEncoding: String?
        /// The language the content is in.
        public let contentLanguage: String?
        /// Size of the body in bytes.
        public let contentLength: Int64?
        /// A standard MIME type describing the format of the object data.
        public let contentType: String?
        /// Specifies whether the object retrieved was (true) or was not (false) a Delete Marker. If false, this response header does not appear in the response.
        public let deleteMarker: Bool?
        /// An ETag is an opaque identifier assigned by a web server to a specific version of a resource found at a URL.
        public let eTag: String?
        /// If the object expiration is configured (see PUT Bucket lifecycle), the response includes this header. It includes the expiry-date and rule-id key-value pairs providing object expiration information. The value of the rule-id is URL encoded.
        public let expiration: String?
        /// The date and time at which the object is no longer cacheable.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var expires: Date?
        /// Creation date of the object.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var lastModified: Date?
        /// A map of metadata to store with the object in S3.
        public let metadata: [String: String]?
        /// This is set to the number of metadata entries not returned in x-amz-meta headers. This can happen if you create metadata using an API like SOAP that supports more flexible metadata than the REST API. For example, using SOAP, you can create metadata whose values are not legal HTTP headers.
        public let missingMeta: Int?
        /// Specifies whether a legal hold is in effect for this object. This header is only returned if the requester has the s3:GetObjectLegalHold permission. This header is not returned if the specified version of this object has never had a legal hold applied. For more information about S3 Object Lock, see Object Lock.
        public let objectLockLegalHoldStatus: ObjectLockLegalHoldStatus?
        /// The Object Lock mode, if any, that's in effect for this object. This header is only returned if the requester has the s3:GetObjectRetention permission. For more information about S3 Object Lock, see Object Lock.
        public let objectLockMode: ObjectLockMode?
        /// The date and time when the Object Lock retention period expires. This header is only returned if the requester has the s3:GetObjectRetention permission.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var objectLockRetainUntilDate: Date?
        /// The count of parts this object has.
        public let partsCount: Int?
        /// Amazon S3 can return this header if your request involves a bucket that is either a source or a destination in a replication rule. In replication, you have a source bucket on which you configure replication and destination bucket or buckets where Amazon S3 stores object replicas. When you request an object (GetObject) or object metadata (HeadObject) from these buckets, Amazon S3 will return the x-amz-replication-status header in the response as follows:   If requesting an object from the source bucket — Amazon S3 will return the x-amz-replication-status header if the object in your request is eligible for replication.  For example, suppose that in your replication configuration, you specify object prefix TaxDocs requesting Amazon S3 to replicate objects with key prefix TaxDocs. Any objects you upload with this key name prefix, for example TaxDocs/document1.pdf, are eligible for replication. For any object request with this key name prefix, Amazon S3 will return the x-amz-replication-status header with value PENDING, COMPLETED or FAILED indicating object replication status.   If requesting an object from a destination bucket — Amazon S3 will return the x-amz-replication-status header with value REPLICA if the object in your request is a replica that Amazon S3 created and there is no replica modification replication in progress.   When replicating objects to multiple destination buckets the x-amz-replication-status header acts differently. The header of the source object will only return a value of COMPLETED when replication is successful to all destinations. The header will remain at value PENDING until replication has completed for all destinations. If one or more destinations fails replication the header will return FAILED.    For more information, see Replication.
        public let replicationStatus: ReplicationStatus?
        public let requestCharged: RequestCharged?
        /// If the object is an archived object (an object whose storage class is GLACIER), the response includes this header if either the archive restoration is in progress (see RestoreObject or an archive copy is already restored.  If an archive copy is already restored, the header value indicates when Amazon S3 is scheduled to delete the object copy. For example:  x-amz-restore: ongoing-request="false", expiry-date="Fri, 23 Dec 2012 00:00:00 GMT"  If the object restoration is in progress, the header returns the value ongoing-request="true". For more information about archiving objects, see Transitioning Objects: General Considerations.
        public let restore: String?
        /// If the object is stored using server-side encryption either with an AWS KMS customer master key (CMK) or an Amazon S3-managed encryption key, the response includes this header with the value of the server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?
        /// Provides storage class information of the object. Amazon S3 returns this header for all objects except for S3 Standard storage class objects. For more information, see Storage Classes.
        public let storageClass: StorageClass?
        /// Version of the object.
        public let versionId: String?
        /// If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.
        public let websiteRedirectLocation: String?

        public init(acceptRanges: String? = nil, archiveStatus: ArchiveStatus? = nil, bucketKeyEnabled: Bool? = nil, cacheControl: String? = nil, contentDisposition: String? = nil, contentEncoding: String? = nil, contentLanguage: String? = nil, contentLength: Int64? = nil, contentType: String? = nil, deleteMarker: Bool? = nil, eTag: String? = nil, expiration: String? = nil, expires: Date? = nil, lastModified: Date? = nil, metadata: [String: String]? = nil, missingMeta: Int? = nil, objectLockLegalHoldStatus: ObjectLockLegalHoldStatus? = nil, objectLockMode: ObjectLockMode? = nil, objectLockRetainUntilDate: Date? = nil, partsCount: Int? = nil, replicationStatus: ReplicationStatus? = nil, requestCharged: RequestCharged? = nil, restore: String? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSKeyId: String? = nil, storageClass: StorageClass? = nil, versionId: String? = nil, websiteRedirectLocation: String? = nil) {
            self.acceptRanges = acceptRanges
            self.archiveStatus = archiveStatus
            self.bucketKeyEnabled = bucketKeyEnabled
            self.cacheControl = cacheControl
            self.contentDisposition = contentDisposition
            self.contentEncoding = contentEncoding
            self.contentLanguage = contentLanguage
            self.contentLength = contentLength
            self.contentType = contentType
            self.deleteMarker = deleteMarker
            self.eTag = eTag
            self.expiration = expiration
            self.expires = expires
            self.lastModified = lastModified
            self.metadata = metadata
            self.missingMeta = missingMeta
            self.objectLockLegalHoldStatus = objectLockLegalHoldStatus
            self.objectLockMode = objectLockMode
            self.objectLockRetainUntilDate = objectLockRetainUntilDate
            self.partsCount = partsCount
            self.replicationStatus = replicationStatus
            self.requestCharged = requestCharged
            self.restore = restore
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSKeyId = sSEKMSKeyId
            self.storageClass = storageClass
            self.versionId = versionId
            self.websiteRedirectLocation = websiteRedirectLocation
        }

        private enum CodingKeys: String, CodingKey {
            case acceptRanges = "accept-ranges"
            case archiveStatus = "x-amz-archive-status"
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case cacheControl = "Cache-Control"
            case contentDisposition = "Content-Disposition"
            case contentEncoding = "Content-Encoding"
            case contentLanguage = "Content-Language"
            case contentLength = "Content-Length"
            case contentType = "Content-Type"
            case deleteMarker = "x-amz-delete-marker"
            case eTag = "ETag"
            case expiration = "x-amz-expiration"
            case expires = "Expires"
            case lastModified = "Last-Modified"
            case metadata = "x-amz-meta-"
            case missingMeta = "x-amz-missing-meta"
            case objectLockLegalHoldStatus = "x-amz-object-lock-legal-hold"
            case objectLockMode = "x-amz-object-lock-mode"
            case objectLockRetainUntilDate = "x-amz-object-lock-retain-until-date"
            case partsCount = "x-amz-mp-parts-count"
            case replicationStatus = "x-amz-replication-status"
            case requestCharged = "x-amz-request-charged"
            case restore = "x-amz-restore"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
            case storageClass = "x-amz-storage-class"
            case versionId = "x-amz-version-id"
            case websiteRedirectLocation = "x-amz-website-redirect-location"
        }
    }

    public struct HeadObjectRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "ifMatch", location: .header(locationName: "If-Match")),
            AWSMemberEncoding(label: "_ifModifiedSince", location: .header(locationName: "If-Modified-Since")),
            AWSMemberEncoding(label: "ifNoneMatch", location: .header(locationName: "If-None-Match")),
            AWSMemberEncoding(label: "_ifUnmodifiedSince", location: .header(locationName: "If-Unmodified-Since")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "partNumber", location: .querystring(locationName: "partNumber")),
            AWSMemberEncoding(label: "range", location: .header(locationName: "Range")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The name of the bucket containing the object. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Return the object only if its entity tag (ETag) is the same as the one specified, otherwise return a 412 (precondition failed).
        public let ifMatch: String?
        /// Return the object only if it has been modified since the specified time, otherwise return a 304 (not modified).
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var ifModifiedSince: Date?
        /// Return the object only if its entity tag (ETag) is different from the one specified, otherwise return a 304 (not modified).
        public let ifNoneMatch: String?
        /// Return the object only if it has not been modified since the specified time, otherwise return a 412 (precondition failed).
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var ifUnmodifiedSince: Date?
        /// The object key.
        public let key: String
        /// Part number of the object being read. This is a positive integer between 1 and 10,000. Effectively performs a 'ranged' HEAD request for the part specified. Useful querying about the size of the part and the number of parts in this object.
        public let partNumber: Int?
        /// Downloads the specified range bytes of an object. For more information about the HTTP Range header, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.  Amazon S3 doesn't support retrieving multiple ranges of data per GET request.
        public let range: String?
        public let requestPayer: RequestPayer?
        /// Specifies the algorithm to use to when encrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This value is used to store the object and then it is discarded; Amazon S3 does not store the encryption key. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// VersionId used to reference a specific version of the object.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, ifMatch: String? = nil, ifModifiedSince: Date? = nil, ifNoneMatch: String? = nil, ifUnmodifiedSince: Date? = nil, key: String, partNumber: Int? = nil, range: String? = nil, requestPayer: RequestPayer? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.ifMatch = ifMatch
            self.ifModifiedSince = ifModifiedSince
            self.ifNoneMatch = ifNoneMatch
            self.ifUnmodifiedSince = ifUnmodifiedSince
            self.key = key
            self.partNumber = partNumber
            self.range = range
            self.requestPayer = requestPayer
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct IndexDocument: AWSEncodableShape & AWSDecodableShape {
        /// A suffix that is appended to a request that is for a directory on the website endpoint (for example,if the suffix is index.html and you make a request to samplebucket/images/ the data that is returned will be for the object with the key name images/index.html) The suffix must not be empty and must not include a slash character.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let suffix: String

        public init(suffix: String) {
            self.suffix = suffix
        }

        private enum CodingKeys: String, CodingKey {
            case suffix = "Suffix"
        }
    }

    public struct Initiator: AWSDecodableShape {
        /// Name of the Principal.
        public let displayName: String?
        /// If the principal is an AWS account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.
        public let id: String?

        public init(displayName: String? = nil, id: String? = nil) {
            self.displayName = displayName
            self.id = id
        }

        private enum CodingKeys: String, CodingKey {
            case displayName = "DisplayName"
            case id = "ID"
        }
    }

    public struct InputSerialization: AWSEncodableShape {
        /// Specifies object's compression format. Valid values: NONE, GZIP, BZIP2. Default Value: NONE.
        public let compressionType: CompressionType?
        /// Describes the serialization of a CSV-encoded object.
        public let csv: CSVInput?
        /// Specifies JSON as object's input serialization format.
        public let json: JSONInput?
        /// Specifies Parquet as object's input serialization format.
        public let parquet: ParquetInput?

        public init(compressionType: CompressionType? = nil, csv: CSVInput? = nil, json: JSONInput? = nil, parquet: ParquetInput? = nil) {
            self.compressionType = compressionType
            self.csv = csv
            self.json = json
            self.parquet = parquet
        }

        private enum CodingKeys: String, CodingKey {
            case compressionType = "CompressionType"
            case csv = "CSV"
            case json = "JSON"
            case parquet = "Parquet"
        }
    }

    public struct IntelligentTieringAndOperator: AWSEncodableShape & AWSDecodableShape {
        /// An object key name prefix that identifies the subset of objects to which the configuration applies.
        public let prefix: String?
        /// All of these tags must exist in the object's tag set in order for the configuration to apply.
        public let tags: [Tag]?

        public init(prefix: String? = nil, tags: [Tag]? = nil) {
            self.prefix = prefix
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
            case tags = "Tag"
        }
    }

    public struct IntelligentTieringConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies a bucket filter. The configuration only includes objects that meet the filter's criteria.
        public let filter: IntelligentTieringFilter?
        /// The ID used to identify the S3 Intelligent-Tiering configuration.
        public let id: String
        /// Specifies the status of the configuration.
        public let status: IntelligentTieringStatus
        /// Specifies the S3 Intelligent-Tiering storage class tier of the configuration.
        public let tierings: [Tiering]

        public init(filter: IntelligentTieringFilter? = nil, id: String, status: IntelligentTieringStatus, tierings: [Tiering]) {
            self.filter = filter
            self.id = id
            self.status = status
            self.tierings = tierings
        }

        public func validate(name: String) throws {
            try self.filter?.validate(name: "\(name).filter")
        }

        private enum CodingKeys: String, CodingKey {
            case filter = "Filter"
            case id = "Id"
            case status = "Status"
            case tierings = "Tiering"
        }
    }

    public struct IntelligentTieringFilter: AWSEncodableShape & AWSDecodableShape {
        /// A conjunction (logical AND) of predicates, which is used in evaluating a metrics filter. The operator must have at least two predicates, and an object must match all of the predicates in order for the filter to apply.
        public let and: IntelligentTieringAndOperator?
        /// An object key name prefix that identifies the subset of objects to which the rule applies.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let prefix: String?
        public let tag: Tag?

        public init(and: IntelligentTieringAndOperator? = nil, prefix: String? = nil, tag: Tag? = nil) {
            self.and = and
            self.prefix = prefix
            self.tag = tag
        }

        public func validate(name: String) throws {
            try self.and?.validate(name: "\(name).and")
            try self.tag?.validate(name: "\(name).tag")
        }

        private enum CodingKeys: String, CodingKey {
            case and = "And"
            case prefix = "Prefix"
            case tag = "Tag"
        }
    }

    public struct InventoryConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"
        public struct _OptionalFieldsEncoding: ArrayCoderProperties { public static let member = "Field" }

        /// Contains information about where to publish the inventory results.
        public let destination: InventoryDestination
        /// Specifies an inventory filter. The inventory only includes objects that meet the filter's criteria.
        public let filter: InventoryFilter?
        /// The ID used to identify the inventory configuration.
        public let id: String
        /// Object versions to include in the inventory list. If set to All, the list includes all the object versions, which adds the version-related fields VersionId, IsLatest, and DeleteMarker to the list. If set to Current, the list does not contain these version-related fields.
        public let includedObjectVersions: InventoryIncludedObjectVersions
        /// Specifies whether the inventory is enabled or disabled. If set to True, an inventory list is generated. If set to False, no inventory list is generated.
        public let isEnabled: Bool
        /// Contains the optional fields that are included in the inventory results.
        @OptionalCustomCoding<ArrayCoder<_OptionalFieldsEncoding, InventoryOptionalField>>
        public var optionalFields: [InventoryOptionalField]?
        /// Specifies the schedule for generating inventory results.
        public let schedule: InventorySchedule

        public init(destination: InventoryDestination, filter: InventoryFilter? = nil, id: String, includedObjectVersions: InventoryIncludedObjectVersions, isEnabled: Bool, optionalFields: [InventoryOptionalField]? = nil, schedule: InventorySchedule) {
            self.destination = destination
            self.filter = filter
            self.id = id
            self.includedObjectVersions = includedObjectVersions
            self.isEnabled = isEnabled
            self.optionalFields = optionalFields
            self.schedule = schedule
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
            case filter = "Filter"
            case id = "Id"
            case includedObjectVersions = "IncludedObjectVersions"
            case isEnabled = "IsEnabled"
            case optionalFields = "OptionalFields"
            case schedule = "Schedule"
        }
    }

    public struct InventoryDestination: AWSEncodableShape & AWSDecodableShape {
        /// Contains the bucket name, file format, bucket owner (optional), and prefix (optional) where inventory results are published.
        public let s3BucketDestination: InventoryS3BucketDestination

        public init(s3BucketDestination: InventoryS3BucketDestination) {
            self.s3BucketDestination = s3BucketDestination
        }

        private enum CodingKeys: String, CodingKey {
            case s3BucketDestination = "S3BucketDestination"
        }
    }

    public struct InventoryEncryption: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the use of SSE-KMS to encrypt delivered inventory reports.
        public let ssekms: SSEKMS?
        /// Specifies the use of SSE-S3 to encrypt delivered inventory reports.
        public let sses3: SSES3?

        public init(ssekms: SSEKMS? = nil, sses3: SSES3? = nil) {
            self.ssekms = ssekms
            self.sses3 = sses3
        }

        private enum CodingKeys: String, CodingKey {
            case ssekms = "SSE-KMS"
            case sses3 = "SSE-S3"
        }
    }

    public struct InventoryFilter: AWSEncodableShape & AWSDecodableShape {
        /// The prefix that an object must have to be included in the inventory results.
        public let prefix: String

        public init(prefix: String) {
            self.prefix = prefix
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
        }
    }

    public struct InventoryS3BucketDestination: AWSEncodableShape & AWSDecodableShape {
        /// The account ID that owns the destination S3 bucket. If no account ID is provided, the owner is not validated before exporting data.    Although this value is optional, we strongly recommend that you set it to help prevent problems if the destination bucket ownership changes.
        public let accountId: String?
        /// The Amazon Resource Name (ARN) of the bucket where inventory results will be published.
        public let bucket: String
        /// Contains the type of server-side encryption used to encrypt the inventory results.
        public let encryption: InventoryEncryption?
        /// Specifies the output format of the inventory results.
        public let format: InventoryFormat
        /// The prefix that is prepended to all inventory results.
        public let prefix: String?

        public init(accountId: String? = nil, bucket: String, encryption: InventoryEncryption? = nil, format: InventoryFormat, prefix: String? = nil) {
            self.accountId = accountId
            self.bucket = bucket
            self.encryption = encryption
            self.format = format
            self.prefix = prefix
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case bucket = "Bucket"
            case encryption = "Encryption"
            case format = "Format"
            case prefix = "Prefix"
        }
    }

    public struct InventorySchedule: AWSEncodableShape & AWSDecodableShape {
        /// Specifies how frequently inventory results are produced.
        public let frequency: InventoryFrequency

        public init(frequency: InventoryFrequency) {
            self.frequency = frequency
        }

        private enum CodingKeys: String, CodingKey {
            case frequency = "Frequency"
        }
    }

    public struct JSONInput: AWSEncodableShape {
        /// The type of JSON. Valid values: Document, Lines.
        public let type: JSONType?

        public init(type: JSONType? = nil) {
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case type = "Type"
        }
    }

    public struct JSONOutput: AWSEncodableShape {
        /// The value used to separate individual records in the output. If no value is specified, Amazon S3 uses a newline character ('\n').
        public let recordDelimiter: String?

        public init(recordDelimiter: String? = nil) {
            self.recordDelimiter = recordDelimiter
        }

        private enum CodingKeys: String, CodingKey {
            case recordDelimiter = "RecordDelimiter"
        }
    }

    public struct LambdaFunctionConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon S3 bucket event for which to invoke the AWS Lambda function. For more information, see Supported Event Types in the Amazon Simple Storage Service Developer Guide.
        public let events: [Event]
        public let filter: NotificationConfigurationFilter?
        public let id: String?
        /// The Amazon Resource Name (ARN) of the AWS Lambda function that Amazon S3 invokes when the specified event type occurs.
        public let lambdaFunctionArn: String

        public init(events: [Event], filter: NotificationConfigurationFilter? = nil, id: String? = nil, lambdaFunctionArn: String) {
            self.events = events
            self.filter = filter
            self.id = id
            self.lambdaFunctionArn = lambdaFunctionArn
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Event"
            case filter = "Filter"
            case id = "Id"
            case lambdaFunctionArn = "CloudFunction"
        }
    }

    public struct LifecycleConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies lifecycle configuration rules for an Amazon S3 bucket.
        public let rules: [Rule]

        public init(rules: [Rule]) {
            self.rules = rules
        }

        private enum CodingKeys: String, CodingKey {
            case rules = "Rule"
        }
    }

    public struct LifecycleExpiration: AWSEncodableShape & AWSDecodableShape {
        /// Indicates at what date the object is to be moved or deleted. Should be in GMT ISO 8601 Format.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var date: Date?
        /// Indicates the lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
        public let days: Int?
        /// Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to true, the delete marker will be expired; if set to false the policy takes no action. This cannot be specified with Days or Date in a Lifecycle Expiration Policy.
        public let expiredObjectDeleteMarker: Bool?

        public init(date: Date? = nil, days: Int? = nil, expiredObjectDeleteMarker: Bool? = nil) {
            self.date = date
            self.days = days
            self.expiredObjectDeleteMarker = expiredObjectDeleteMarker
        }

        private enum CodingKeys: String, CodingKey {
            case date = "Date"
            case days = "Days"
            case expiredObjectDeleteMarker = "ExpiredObjectDeleteMarker"
        }
    }

    public struct LifecycleRule: AWSEncodableShape & AWSDecodableShape {
        public let abortIncompleteMultipartUpload: AbortIncompleteMultipartUpload?
        /// Specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker.
        public let expiration: LifecycleExpiration?
        public let filter: LifecycleRuleFilter
        /// Unique identifier for the rule. The value cannot be longer than 255 characters.
        public let id: String?
        public let noncurrentVersionExpiration: NoncurrentVersionExpiration?
        ///  Specifies the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. If your bucket is versioning-enabled (or versioning is suspended), you can set this action to request that Amazon S3 transition noncurrent object versions to a specific storage class at a set period in the object's lifetime.
        public let noncurrentVersionTransitions: [NoncurrentVersionTransition]?
        /// If 'Enabled', the rule is currently being applied. If 'Disabled', the rule is not currently being applied.
        public let status: ExpirationStatus
        /// Specifies when an Amazon S3 object transitions to a specified storage class.
        public let transitions: [Transition]?

        public init(abortIncompleteMultipartUpload: AbortIncompleteMultipartUpload? = nil, expiration: LifecycleExpiration? = nil, filter: LifecycleRuleFilter, id: String? = nil, noncurrentVersionExpiration: NoncurrentVersionExpiration? = nil, noncurrentVersionTransitions: [NoncurrentVersionTransition]? = nil, status: ExpirationStatus, transitions: [Transition]? = nil) {
            self.abortIncompleteMultipartUpload = abortIncompleteMultipartUpload
            self.expiration = expiration
            self.filter = filter
            self.id = id
            self.noncurrentVersionExpiration = noncurrentVersionExpiration
            self.noncurrentVersionTransitions = noncurrentVersionTransitions
            self.status = status
            self.transitions = transitions
        }

        public func validate(name: String) throws {
            try self.filter.validate(name: "\(name).filter")
        }

        private enum CodingKeys: String, CodingKey {
            case abortIncompleteMultipartUpload = "AbortIncompleteMultipartUpload"
            case expiration = "Expiration"
            case filter = "Filter"
            case id = "ID"
            case noncurrentVersionExpiration = "NoncurrentVersionExpiration"
            case noncurrentVersionTransitions = "NoncurrentVersionTransition"
            case status = "Status"
            case transitions = "Transition"
        }
    }

    public struct LifecycleRuleAndOperator: AWSEncodableShape & AWSDecodableShape {
        /// Prefix identifying one or more objects to which the rule applies.
        public let prefix: String?
        /// All of these tags must exist in the object's tag set in order for the rule to apply.
        public let tags: [Tag]?

        public init(prefix: String? = nil, tags: [Tag]? = nil) {
            self.prefix = prefix
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
            case tags = "Tag"
        }
    }

    public struct LifecycleRuleFilter: AWSEncodableShape & AWSDecodableShape {
        public let and: LifecycleRuleAndOperator?
        /// Prefix identifying one or more objects to which the rule applies.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let prefix: String?
        /// This tag must exist in the object's tag set in order for the rule to apply.
        public let tag: Tag?

        public init(and: LifecycleRuleAndOperator? = nil, prefix: String? = nil, tag: Tag? = nil) {
            self.and = and
            self.prefix = prefix
            self.tag = tag
        }

        public func validate(name: String) throws {
            try self.and?.validate(name: "\(name).and")
            try self.tag?.validate(name: "\(name).tag")
        }

        private enum CodingKeys: String, CodingKey {
            case and = "And"
            case prefix = "Prefix"
            case tag = "Tag"
        }
    }

    public struct ListBucketAnalyticsConfigurationsOutput: AWSDecodableShape {
        /// The list of analytics configurations for a bucket.
        public let analyticsConfigurationList: [AnalyticsConfiguration]?
        /// The marker that is used as a starting point for this analytics configuration list response. This value is present if it was sent in the request.
        public let continuationToken: String?
        /// Indicates whether the returned list of analytics configurations is complete. A value of true indicates that the list is not complete and the NextContinuationToken will be provided for a subsequent request.
        public let isTruncated: Bool?
        ///  NextContinuationToken is sent when isTruncated is true, which indicates that there are more analytics configurations to list. The next request must include this NextContinuationToken. The token is obfuscated and is not a usable value.
        public let nextContinuationToken: String?

        public init(analyticsConfigurationList: [AnalyticsConfiguration]? = nil, continuationToken: String? = nil, isTruncated: Bool? = nil, nextContinuationToken: String? = nil) {
            self.analyticsConfigurationList = analyticsConfigurationList
            self.continuationToken = continuationToken
            self.isTruncated = isTruncated
            self.nextContinuationToken = nextContinuationToken
        }

        private enum CodingKeys: String, CodingKey {
            case analyticsConfigurationList = "AnalyticsConfiguration"
            case continuationToken = "ContinuationToken"
            case isTruncated = "IsTruncated"
            case nextContinuationToken = "NextContinuationToken"
        }
    }

    public struct ListBucketAnalyticsConfigurationsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "continuationToken", location: .querystring(locationName: "continuation-token")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket from which analytics configurations are retrieved.
        public let bucket: String
        /// The ContinuationToken that represents a placeholder from where this request should begin.
        public let continuationToken: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, continuationToken: String? = nil, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.continuationToken = continuationToken
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListBucketIntelligentTieringConfigurationsOutput: AWSDecodableShape {
        /// The ContinuationToken that represents a placeholder from where this request should begin.
        public let continuationToken: String?
        /// The list of S3 Intelligent-Tiering configurations for a bucket.
        public let intelligentTieringConfigurationList: [IntelligentTieringConfiguration]?
        /// Indicates whether the returned list of analytics configurations is complete. A value of true indicates that the list is not complete and the NextContinuationToken will be provided for a subsequent request.
        public let isTruncated: Bool?
        /// The marker used to continue this inventory configuration listing. Use the NextContinuationToken from this response to continue the listing in a subsequent request. The continuation token is an opaque value that Amazon S3 understands.
        public let nextContinuationToken: String?

        public init(continuationToken: String? = nil, intelligentTieringConfigurationList: [IntelligentTieringConfiguration]? = nil, isTruncated: Bool? = nil, nextContinuationToken: String? = nil) {
            self.continuationToken = continuationToken
            self.intelligentTieringConfigurationList = intelligentTieringConfigurationList
            self.isTruncated = isTruncated
            self.nextContinuationToken = nextContinuationToken
        }

        private enum CodingKeys: String, CodingKey {
            case continuationToken = "ContinuationToken"
            case intelligentTieringConfigurationList = "IntelligentTieringConfiguration"
            case isTruncated = "IsTruncated"
            case nextContinuationToken = "NextContinuationToken"
        }
    }

    public struct ListBucketIntelligentTieringConfigurationsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "continuationToken", location: .querystring(locationName: "continuation-token"))
        ]

        /// The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.
        public let bucket: String
        /// The ContinuationToken that represents a placeholder from where this request should begin.
        public let continuationToken: String?

        public init(bucket: String, continuationToken: String? = nil) {
            self.bucket = bucket
            self.continuationToken = continuationToken
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListBucketInventoryConfigurationsOutput: AWSDecodableShape {
        /// If sent in the request, the marker that is used as a starting point for this inventory configuration list response.
        public let continuationToken: String?
        /// The list of inventory configurations for a bucket.
        public let inventoryConfigurationList: [InventoryConfiguration]?
        /// Tells whether the returned list of inventory configurations is complete. A value of true indicates that the list is not complete and the NextContinuationToken is provided for a subsequent request.
        public let isTruncated: Bool?
        /// The marker used to continue this inventory configuration listing. Use the NextContinuationToken from this response to continue the listing in a subsequent request. The continuation token is an opaque value that Amazon S3 understands.
        public let nextContinuationToken: String?

        public init(continuationToken: String? = nil, inventoryConfigurationList: [InventoryConfiguration]? = nil, isTruncated: Bool? = nil, nextContinuationToken: String? = nil) {
            self.continuationToken = continuationToken
            self.inventoryConfigurationList = inventoryConfigurationList
            self.isTruncated = isTruncated
            self.nextContinuationToken = nextContinuationToken
        }

        private enum CodingKeys: String, CodingKey {
            case continuationToken = "ContinuationToken"
            case inventoryConfigurationList = "InventoryConfiguration"
            case isTruncated = "IsTruncated"
            case nextContinuationToken = "NextContinuationToken"
        }
    }

    public struct ListBucketInventoryConfigurationsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "continuationToken", location: .querystring(locationName: "continuation-token")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket containing the inventory configurations to retrieve.
        public let bucket: String
        /// The marker used to continue an inventory configuration listing that has been truncated. Use the NextContinuationToken from a previously truncated list response to continue the listing. The continuation token is an opaque value that Amazon S3 understands.
        public let continuationToken: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, continuationToken: String? = nil, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.continuationToken = continuationToken
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListBucketMetricsConfigurationsOutput: AWSDecodableShape {
        /// The marker that is used as a starting point for this metrics configuration list response. This value is present if it was sent in the request.
        public let continuationToken: String?
        /// Indicates whether the returned list of metrics configurations is complete. A value of true indicates that the list is not complete and the NextContinuationToken will be provided for a subsequent request.
        public let isTruncated: Bool?
        /// The list of metrics configurations for a bucket.
        public let metricsConfigurationList: [MetricsConfiguration]?
        /// The marker used to continue a metrics configuration listing that has been truncated. Use the NextContinuationToken from a previously truncated list response to continue the listing. The continuation token is an opaque value that Amazon S3 understands.
        public let nextContinuationToken: String?

        public init(continuationToken: String? = nil, isTruncated: Bool? = nil, metricsConfigurationList: [MetricsConfiguration]? = nil, nextContinuationToken: String? = nil) {
            self.continuationToken = continuationToken
            self.isTruncated = isTruncated
            self.metricsConfigurationList = metricsConfigurationList
            self.nextContinuationToken = nextContinuationToken
        }

        private enum CodingKeys: String, CodingKey {
            case continuationToken = "ContinuationToken"
            case isTruncated = "IsTruncated"
            case metricsConfigurationList = "MetricsConfiguration"
            case nextContinuationToken = "NextContinuationToken"
        }
    }

    public struct ListBucketMetricsConfigurationsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "continuationToken", location: .querystring(locationName: "continuation-token")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket containing the metrics configurations to retrieve.
        public let bucket: String
        /// The marker that is used to continue a metrics configuration listing that has been truncated. Use the NextContinuationToken from a previously truncated list response to continue the listing. The continuation token is an opaque value that Amazon S3 understands.
        public let continuationToken: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, continuationToken: String? = nil, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.continuationToken = continuationToken
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListBucketsOutput: AWSDecodableShape {
        public struct _BucketsEncoding: ArrayCoderProperties { public static let member = "Bucket" }

        /// The list of buckets owned by the requestor.
        @OptionalCustomCoding<ArrayCoder<_BucketsEncoding, Bucket>>
        public var buckets: [Bucket]?
        /// The owner of the buckets listed.
        public let owner: Owner?

        public init(buckets: [Bucket]? = nil, owner: Owner? = nil) {
            self.buckets = buckets
            self.owner = owner
        }

        private enum CodingKeys: String, CodingKey {
            case buckets = "Buckets"
            case owner = "Owner"
        }
    }

    public struct ListMultipartUploadsOutput: AWSDecodableShape {
        /// The name of the bucket to which the multipart upload was initiated.
        public let bucket: String?
        /// If you specify a delimiter in the request, then the result returns each distinct key prefix containing the delimiter in a CommonPrefixes element. The distinct key prefixes are returned in the Prefix child element.
        public let commonPrefixes: [CommonPrefix]?
        /// Contains the delimiter you specified in the request. If you don't specify a delimiter in your request, this element is absent from the response.
        public let delimiter: String?
        /// Encoding type used by Amazon S3 to encode object keys in the response. If you specify encoding-type request parameter, Amazon S3 includes this element in the response, and returns encoded key name values in the following response elements:  Delimiter, KeyMarker, Prefix, NextKeyMarker, Key.
        public let encodingType: EncodingType?
        /// Indicates whether the returned list of multipart uploads is truncated. A value of true indicates that the list was truncated. The list can be truncated if the number of multipart uploads exceeds the limit allowed or specified by max uploads.
        public let isTruncated: Bool?
        /// The key at or after which the listing began.
        public let keyMarker: String?
        /// Maximum number of multipart uploads that could have been included in the response.
        public let maxUploads: Int?
        /// When a list is truncated, this element specifies the value that should be used for the key-marker request parameter in a subsequent request.
        public let nextKeyMarker: String?
        /// When a list is truncated, this element specifies the value that should be used for the upload-id-marker request parameter in a subsequent request.
        public let nextUploadIdMarker: String?
        /// When a prefix is provided in the request, this field contains the specified prefix. The result contains only keys starting with the specified prefix.
        public let prefix: String?
        /// Upload ID after which listing began.
        public let uploadIdMarker: String?
        /// Container for elements related to a particular multipart upload. A response can contain zero or more Upload elements.
        public let uploads: [MultipartUpload]?

        public init(bucket: String? = nil, commonPrefixes: [CommonPrefix]? = nil, delimiter: String? = nil, encodingType: EncodingType? = nil, isTruncated: Bool? = nil, keyMarker: String? = nil, maxUploads: Int? = nil, nextKeyMarker: String? = nil, nextUploadIdMarker: String? = nil, prefix: String? = nil, uploadIdMarker: String? = nil, uploads: [MultipartUpload]? = nil) {
            self.bucket = bucket
            self.commonPrefixes = commonPrefixes
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.isTruncated = isTruncated
            self.keyMarker = keyMarker
            self.maxUploads = maxUploads
            self.nextKeyMarker = nextKeyMarker
            self.nextUploadIdMarker = nextUploadIdMarker
            self.prefix = prefix
            self.uploadIdMarker = uploadIdMarker
            self.uploads = uploads
        }

        private enum CodingKeys: String, CodingKey {
            case bucket = "Bucket"
            case commonPrefixes = "CommonPrefixes"
            case delimiter = "Delimiter"
            case encodingType = "EncodingType"
            case isTruncated = "IsTruncated"
            case keyMarker = "KeyMarker"
            case maxUploads = "MaxUploads"
            case nextKeyMarker = "NextKeyMarker"
            case nextUploadIdMarker = "NextUploadIdMarker"
            case prefix = "Prefix"
            case uploadIdMarker = "UploadIdMarker"
            case uploads = "Upload"
        }
    }

    public struct ListMultipartUploadsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "delimiter", location: .querystring(locationName: "delimiter")),
            AWSMemberEncoding(label: "encodingType", location: .querystring(locationName: "encoding-type")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "keyMarker", location: .querystring(locationName: "key-marker")),
            AWSMemberEncoding(label: "maxUploads", location: .querystring(locationName: "max-uploads")),
            AWSMemberEncoding(label: "prefix", location: .querystring(locationName: "prefix")),
            AWSMemberEncoding(label: "uploadIdMarker", location: .querystring(locationName: "upload-id-marker"))
        ]

        /// The name of the bucket to which the multipart upload was initiated.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Character you use to group keys. All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, CommonPrefixes. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under CommonPrefixes result element are not returned elsewhere in the response.
        public let delimiter: String?
        public let encodingType: EncodingType?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Together with upload-id-marker, this parameter specifies the multipart upload after which listing should begin. If upload-id-marker is not specified, only the keys lexicographically greater than the specified key-marker will be included in the list. If upload-id-marker is specified, any multipart uploads for a key equal to the key-marker might also be included, provided those multipart uploads have upload IDs lexicographically greater than the specified upload-id-marker.
        public let keyMarker: String?
        /// Sets the maximum number of multipart uploads, from 1 to 1,000, to return in the response body. 1,000 is the maximum number of uploads that can be returned in a response.
        public let maxUploads: Int?
        /// Lists in-progress uploads only for those keys that begin with the specified prefix. You can use prefixes to separate a bucket into different grouping of keys. (You can think of using prefix to make groups in the same way you'd use a folder in a file system.)
        public let prefix: String?
        /// Together with key-marker, specifies the multipart upload after which listing should begin. If key-marker is not specified, the upload-id-marker parameter is ignored. Otherwise, any multipart uploads for a key equal to the key-marker might be included in the list only if they have an upload ID lexicographically greater than the specified upload-id-marker.
        public let uploadIdMarker: String?

        public init(bucket: String, delimiter: String? = nil, encodingType: EncodingType? = nil, expectedBucketOwner: String? = nil, keyMarker: String? = nil, maxUploads: Int? = nil, prefix: String? = nil, uploadIdMarker: String? = nil) {
            self.bucket = bucket
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.expectedBucketOwner = expectedBucketOwner
            self.keyMarker = keyMarker
            self.maxUploads = maxUploads
            self.prefix = prefix
            self.uploadIdMarker = uploadIdMarker
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListObjectVersionsOutput: AWSDecodableShape {
        /// All of the keys rolled up into a common prefix count as a single return when calculating the number of returns.
        public let commonPrefixes: [CommonPrefix]?
        /// Container for an object that is a delete marker.
        public let deleteMarkers: [DeleteMarkerEntry]?
        /// The delimiter grouping the included keys. A delimiter is a character that you specify to group keys. All keys that contain the same string between the prefix and the first occurrence of the delimiter are grouped under a single result element in CommonPrefixes. These groups are counted as one result against the max-keys limitation. These keys are not returned elsewhere in the response.
        public let delimiter: String?
        ///  Encoding type used by Amazon S3 to encode object key names in the XML response. If you specify encoding-type request parameter, Amazon S3 includes this element in the response, and returns encoded key name values in the following response elements:  KeyMarker, NextKeyMarker, Prefix, Key, and Delimiter.
        public let encodingType: EncodingType?
        /// A flag that indicates whether Amazon S3 returned all of the results that satisfied the search criteria. If your results were truncated, you can make a follow-up paginated request using the NextKeyMarker and NextVersionIdMarker response parameters as a starting place in another request to return the rest of the results.
        public let isTruncated: Bool?
        /// Marks the last key returned in a truncated response.
        public let keyMarker: String?
        /// Specifies the maximum number of objects to return.
        public let maxKeys: Int?
        /// The bucket name.
        public let name: String?
        /// When the number of responses exceeds the value of MaxKeys, NextKeyMarker specifies the first key not returned that satisfies the search criteria. Use this value for the key-marker request parameter in a subsequent request.
        public let nextKeyMarker: String?
        /// When the number of responses exceeds the value of MaxKeys, NextVersionIdMarker specifies the first object version not returned that satisfies the search criteria. Use this value for the version-id-marker request parameter in a subsequent request.
        public let nextVersionIdMarker: String?
        /// Selects objects that start with the value supplied by this parameter.
        public let prefix: String?
        /// Marks the last version of the key returned in a truncated response.
        public let versionIdMarker: String?
        /// Container for version information.
        public let versions: [ObjectVersion]?

        public init(commonPrefixes: [CommonPrefix]? = nil, deleteMarkers: [DeleteMarkerEntry]? = nil, delimiter: String? = nil, encodingType: EncodingType? = nil, isTruncated: Bool? = nil, keyMarker: String? = nil, maxKeys: Int? = nil, name: String? = nil, nextKeyMarker: String? = nil, nextVersionIdMarker: String? = nil, prefix: String? = nil, versionIdMarker: String? = nil, versions: [ObjectVersion]? = nil) {
            self.commonPrefixes = commonPrefixes
            self.deleteMarkers = deleteMarkers
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.isTruncated = isTruncated
            self.keyMarker = keyMarker
            self.maxKeys = maxKeys
            self.name = name
            self.nextKeyMarker = nextKeyMarker
            self.nextVersionIdMarker = nextVersionIdMarker
            self.prefix = prefix
            self.versionIdMarker = versionIdMarker
            self.versions = versions
        }

        private enum CodingKeys: String, CodingKey {
            case commonPrefixes = "CommonPrefixes"
            case deleteMarkers = "DeleteMarker"
            case delimiter = "Delimiter"
            case encodingType = "EncodingType"
            case isTruncated = "IsTruncated"
            case keyMarker = "KeyMarker"
            case maxKeys = "MaxKeys"
            case name = "Name"
            case nextKeyMarker = "NextKeyMarker"
            case nextVersionIdMarker = "NextVersionIdMarker"
            case prefix = "Prefix"
            case versionIdMarker = "VersionIdMarker"
            case versions = "Version"
        }
    }

    public struct ListObjectVersionsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "delimiter", location: .querystring(locationName: "delimiter")),
            AWSMemberEncoding(label: "encodingType", location: .querystring(locationName: "encoding-type")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "keyMarker", location: .querystring(locationName: "key-marker")),
            AWSMemberEncoding(label: "maxKeys", location: .querystring(locationName: "max-keys")),
            AWSMemberEncoding(label: "prefix", location: .querystring(locationName: "prefix")),
            AWSMemberEncoding(label: "versionIdMarker", location: .querystring(locationName: "version-id-marker"))
        ]

        /// The bucket name that contains the objects.
        public let bucket: String
        /// A delimiter is a character that you specify to group keys. All keys that contain the same string between the prefix and the first occurrence of the delimiter are grouped under a single result element in CommonPrefixes. These groups are counted as one result against the max-keys limitation. These keys are not returned elsewhere in the response.
        public let delimiter: String?
        public let encodingType: EncodingType?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Specifies the key to start with when listing objects in a bucket.
        public let keyMarker: String?
        /// Sets the maximum number of keys returned in the response. By default the API returns up to 1,000 key names. The response might contain fewer keys but will never contain more. If additional keys satisfy the search criteria, but were not returned because max-keys was exceeded, the response contains &lt;isTruncated&gt;true&lt;/isTruncated&gt;. To return the additional keys, see key-marker and version-id-marker.
        public let maxKeys: Int?
        /// Use this parameter to select only those keys that begin with the specified prefix. You can use prefixes to separate a bucket into different groupings of keys. (You can think of using prefix to make groups in the same way you'd use a folder in a file system.) You can use prefix with delimiter to roll up numerous objects into a single result under CommonPrefixes.
        public let prefix: String?
        /// Specifies the object version you want to start listing from.
        public let versionIdMarker: String?

        public init(bucket: String, delimiter: String? = nil, encodingType: EncodingType? = nil, expectedBucketOwner: String? = nil, keyMarker: String? = nil, maxKeys: Int? = nil, prefix: String? = nil, versionIdMarker: String? = nil) {
            self.bucket = bucket
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.expectedBucketOwner = expectedBucketOwner
            self.keyMarker = keyMarker
            self.maxKeys = maxKeys
            self.prefix = prefix
            self.versionIdMarker = versionIdMarker
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListObjectsOutput: AWSDecodableShape {
        /// All of the keys (up to 1,000) rolled up in a common prefix count as a single return when calculating the number of returns.  A response can contain CommonPrefixes only if you specify a delimiter. CommonPrefixes contains all (if there are any) keys between Prefix and the next occurrence of the string specified by the delimiter.  CommonPrefixes lists keys that act like subdirectories in the directory specified by Prefix. For example, if the prefix is notes/ and the delimiter is a slash (/) as in notes/summer/july, the common prefix is notes/summer/. All of the keys that roll up into a common prefix count as a single return when calculating the number of returns.
        public let commonPrefixes: [CommonPrefix]?
        /// Metadata about each object returned.
        public let contents: [Object]?
        /// Causes keys that contain the same string between the prefix and the first occurrence of the delimiter to be rolled up into a single result element in the CommonPrefixes collection. These rolled-up keys are not returned elsewhere in the response. Each rolled-up result counts as only one return against the MaxKeys value.
        public let delimiter: String?
        /// Encoding type used by Amazon S3 to encode object keys in the response.
        public let encodingType: EncodingType?
        /// A flag that indicates whether Amazon S3 returned all of the results that satisfied the search criteria.
        public let isTruncated: Bool?
        /// Indicates where in the bucket listing begins. Marker is included in the response if it was sent with the request.
        public let marker: String?
        /// The maximum number of keys returned in the response body.
        public let maxKeys: Int?
        /// The bucket name.
        public let name: String?
        /// When response is truncated (the IsTruncated element value in the response is true), you can use the key name in this field as marker in the subsequent request to get next set of objects. Amazon S3 lists objects in alphabetical order Note: This element is returned only if you have delimiter request parameter specified. If response does not include the NextMarker and it is truncated, you can use the value of the last Key in the response as the marker in the subsequent request to get the next set of object keys.
        public let nextMarker: String?
        /// Keys that begin with the indicated prefix.
        public let prefix: String?

        public init(commonPrefixes: [CommonPrefix]? = nil, contents: [Object]? = nil, delimiter: String? = nil, encodingType: EncodingType? = nil, isTruncated: Bool? = nil, marker: String? = nil, maxKeys: Int? = nil, name: String? = nil, nextMarker: String? = nil, prefix: String? = nil) {
            self.commonPrefixes = commonPrefixes
            self.contents = contents
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.isTruncated = isTruncated
            self.marker = marker
            self.maxKeys = maxKeys
            self.name = name
            self.nextMarker = nextMarker
            self.prefix = prefix
        }

        private enum CodingKeys: String, CodingKey {
            case commonPrefixes = "CommonPrefixes"
            case contents = "Contents"
            case delimiter = "Delimiter"
            case encodingType = "EncodingType"
            case isTruncated = "IsTruncated"
            case marker = "Marker"
            case maxKeys = "MaxKeys"
            case name = "Name"
            case nextMarker = "NextMarker"
            case prefix = "Prefix"
        }
    }

    public struct ListObjectsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "delimiter", location: .querystring(locationName: "delimiter")),
            AWSMemberEncoding(label: "encodingType", location: .querystring(locationName: "encoding-type")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "marker", location: .querystring(locationName: "marker")),
            AWSMemberEncoding(label: "maxKeys", location: .querystring(locationName: "max-keys")),
            AWSMemberEncoding(label: "prefix", location: .querystring(locationName: "prefix")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer"))
        ]

        /// The name of the bucket containing the objects. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// A delimiter is a character you use to group keys.
        public let delimiter: String?
        public let encodingType: EncodingType?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Specifies the key to start with when listing objects in a bucket.
        public let marker: String?
        /// Sets the maximum number of keys returned in the response. By default the API returns up to 1,000 key names. The response might contain fewer keys but will never contain more.
        public let maxKeys: Int?
        /// Limits the response to keys that begin with the specified prefix.
        public let prefix: String?
        /// Confirms that the requester knows that she or he will be charged for the list objects request. Bucket owners need not specify this parameter in their requests.
        public let requestPayer: RequestPayer?

        public init(bucket: String, delimiter: String? = nil, encodingType: EncodingType? = nil, expectedBucketOwner: String? = nil, marker: String? = nil, maxKeys: Int? = nil, prefix: String? = nil, requestPayer: RequestPayer? = nil) {
            self.bucket = bucket
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.expectedBucketOwner = expectedBucketOwner
            self.marker = marker
            self.maxKeys = maxKeys
            self.prefix = prefix
            self.requestPayer = requestPayer
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListObjectsV2Output: AWSDecodableShape {
        /// All of the keys (up to 1,000) rolled up into a common prefix count as a single return when calculating the number of returns. A response can contain CommonPrefixes only if you specify a delimiter.  CommonPrefixes contains all (if there are any) keys between Prefix and the next occurrence of the string specified by a delimiter.  CommonPrefixes lists keys that act like subdirectories in the directory specified by Prefix. For example, if the prefix is notes/ and the delimiter is a slash (/) as in notes/summer/july, the common prefix is notes/summer/. All of the keys that roll up into a common prefix count as a single return when calculating the number of returns.
        public let commonPrefixes: [CommonPrefix]?
        /// Metadata about each object returned.
        public let contents: [Object]?
        ///  If ContinuationToken was sent with the request, it is included in the response.
        public let continuationToken: String?
        /// Causes keys that contain the same string between the prefix and the first occurrence of the delimiter to be rolled up into a single result element in the CommonPrefixes collection. These rolled-up keys are not returned elsewhere in the response. Each rolled-up result counts as only one return against the MaxKeys value.
        public let delimiter: String?
        /// Encoding type used by Amazon S3 to encode object key names in the XML response. If you specify the encoding-type request parameter, Amazon S3 includes this element in the response, and returns encoded key name values in the following response elements:  Delimiter, Prefix, Key, and StartAfter.
        public let encodingType: EncodingType?
        /// Set to false if all of the results were returned. Set to true if more keys are available to return. If the number of results exceeds that specified by MaxKeys, all of the results might not be returned.
        public let isTruncated: Bool?
        /// KeyCount is the number of keys returned with this request. KeyCount will always be less than or equals to MaxKeys field. Say you ask for 50 keys, your result will include less than equals 50 keys
        public let keyCount: Int?
        /// Sets the maximum number of keys returned in the response. By default the API returns up to 1,000 key names. The response might contain fewer keys but will never contain more.
        public let maxKeys: Int?
        /// The bucket name. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let name: String?
        ///  NextContinuationToken is sent when isTruncated is true, which means there are more keys in the bucket that can be listed. The next list requests to Amazon S3 can be continued with this NextContinuationToken. NextContinuationToken is obfuscated and is not a real key
        public let nextContinuationToken: String?
        ///  Keys that begin with the indicated prefix.
        public let prefix: String?
        /// If StartAfter was sent with the request, it is included in the response.
        public let startAfter: String?

        public init(commonPrefixes: [CommonPrefix]? = nil, contents: [Object]? = nil, continuationToken: String? = nil, delimiter: String? = nil, encodingType: EncodingType? = nil, isTruncated: Bool? = nil, keyCount: Int? = nil, maxKeys: Int? = nil, name: String? = nil, nextContinuationToken: String? = nil, prefix: String? = nil, startAfter: String? = nil) {
            self.commonPrefixes = commonPrefixes
            self.contents = contents
            self.continuationToken = continuationToken
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.isTruncated = isTruncated
            self.keyCount = keyCount
            self.maxKeys = maxKeys
            self.name = name
            self.nextContinuationToken = nextContinuationToken
            self.prefix = prefix
            self.startAfter = startAfter
        }

        private enum CodingKeys: String, CodingKey {
            case commonPrefixes = "CommonPrefixes"
            case contents = "Contents"
            case continuationToken = "ContinuationToken"
            case delimiter = "Delimiter"
            case encodingType = "EncodingType"
            case isTruncated = "IsTruncated"
            case keyCount = "KeyCount"
            case maxKeys = "MaxKeys"
            case name = "Name"
            case nextContinuationToken = "NextContinuationToken"
            case prefix = "Prefix"
            case startAfter = "StartAfter"
        }
    }

    public struct ListObjectsV2Request: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "continuationToken", location: .querystring(locationName: "continuation-token")),
            AWSMemberEncoding(label: "delimiter", location: .querystring(locationName: "delimiter")),
            AWSMemberEncoding(label: "encodingType", location: .querystring(locationName: "encoding-type")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "fetchOwner", location: .querystring(locationName: "fetch-owner")),
            AWSMemberEncoding(label: "maxKeys", location: .querystring(locationName: "max-keys")),
            AWSMemberEncoding(label: "prefix", location: .querystring(locationName: "prefix")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "startAfter", location: .querystring(locationName: "start-after"))
        ]

        /// Bucket name to list.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// ContinuationToken indicates Amazon S3 that the list is being continued on this bucket with a token. ContinuationToken is obfuscated and is not a real key.
        public let continuationToken: String?
        /// A delimiter is a character you use to group keys.
        public let delimiter: String?
        /// Encoding type used by Amazon S3 to encode object keys in the response.
        public let encodingType: EncodingType?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The owner field is not present in listV2 by default, if you want to return owner field with each key in the result then set the fetch owner field to true.
        public let fetchOwner: Bool?
        /// Sets the maximum number of keys returned in the response. By default the API returns up to 1,000 key names. The response might contain fewer keys but will never contain more.
        public let maxKeys: Int?
        /// Limits the response to keys that begin with the specified prefix.
        public let prefix: String?
        /// Confirms that the requester knows that she or he will be charged for the list objects request in V2 style. Bucket owners need not specify this parameter in their requests.
        public let requestPayer: RequestPayer?
        /// StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts listing after this specified key. StartAfter can be any key in the bucket.
        public let startAfter: String?

        public init(bucket: String, continuationToken: String? = nil, delimiter: String? = nil, encodingType: EncodingType? = nil, expectedBucketOwner: String? = nil, fetchOwner: Bool? = nil, maxKeys: Int? = nil, prefix: String? = nil, requestPayer: RequestPayer? = nil, startAfter: String? = nil) {
            self.bucket = bucket
            self.continuationToken = continuationToken
            self.delimiter = delimiter
            self.encodingType = encodingType
            self.expectedBucketOwner = expectedBucketOwner
            self.fetchOwner = fetchOwner
            self.maxKeys = maxKeys
            self.prefix = prefix
            self.requestPayer = requestPayer
            self.startAfter = startAfter
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListPartsOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "abortDate", location: .header(locationName: "x-amz-abort-date")),
            AWSMemberEncoding(label: "abortRuleId", location: .header(locationName: "x-amz-abort-rule-id")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        /// If the bucket has a lifecycle rule configured with an action to abort incomplete multipart uploads and the prefix in the lifecycle rule matches the object name in the request, then the response includes this header indicating when the initiated multipart upload will become eligible for abort operation. For more information, see Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Policy. The response will also include the x-amz-abort-rule-id header that will provide the ID of the lifecycle configuration rule that defines this action.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var abortDate: Date?
        /// This header is returned along with the x-amz-abort-date header. It identifies applicable lifecycle configuration rule that defines the action to abort incomplete multipart uploads.
        public let abortRuleId: String?
        /// The name of the bucket to which the multipart upload was initiated.
        public let bucket: String?
        /// Container element that identifies who initiated the multipart upload. If the initiator is an AWS account, this element provides the same information as the Owner element. If the initiator is an IAM User, this element provides the user ARN and display name.
        public let initiator: Initiator?
        ///  Indicates whether the returned list of parts is truncated. A true value indicates that the list was truncated. A list can be truncated if the number of parts exceeds the limit returned in the MaxParts element.
        public let isTruncated: Bool?
        /// Object key for which the multipart upload was initiated.
        public let key: String?
        /// Maximum number of parts that were allowed in the response.
        public let maxParts: Int?
        /// When a list is truncated, this element specifies the last part in the list, as well as the value to use for the part-number-marker request parameter in a subsequent request.
        public let nextPartNumberMarker: Int?
        ///  Container element that identifies the object owner, after the object is created. If multipart upload is initiated by an IAM user, this element provides the parent account ID and display name.
        public let owner: Owner?
        /// When a list is truncated, this element specifies the last part in the list, as well as the value to use for the part-number-marker request parameter in a subsequent request.
        public let partNumberMarker: Int?
        ///  Container for elements related to a particular part. A response can contain zero or more Part elements.
        public let parts: [Part]?
        public let requestCharged: RequestCharged?
        /// Class of storage (STANDARD or REDUCED_REDUNDANCY) used to store the uploaded object.
        public let storageClass: StorageClass?
        /// Upload ID identifying the multipart upload whose parts are being listed.
        public let uploadId: String?

        public init(abortDate: Date? = nil, abortRuleId: String? = nil, bucket: String? = nil, initiator: Initiator? = nil, isTruncated: Bool? = nil, key: String? = nil, maxParts: Int? = nil, nextPartNumberMarker: Int? = nil, owner: Owner? = nil, partNumberMarker: Int? = nil, parts: [Part]? = nil, requestCharged: RequestCharged? = nil, storageClass: StorageClass? = nil, uploadId: String? = nil) {
            self.abortDate = abortDate
            self.abortRuleId = abortRuleId
            self.bucket = bucket
            self.initiator = initiator
            self.isTruncated = isTruncated
            self.key = key
            self.maxParts = maxParts
            self.nextPartNumberMarker = nextPartNumberMarker
            self.owner = owner
            self.partNumberMarker = partNumberMarker
            self.parts = parts
            self.requestCharged = requestCharged
            self.storageClass = storageClass
            self.uploadId = uploadId
        }

        private enum CodingKeys: String, CodingKey {
            case abortDate = "x-amz-abort-date"
            case abortRuleId = "x-amz-abort-rule-id"
            case bucket = "Bucket"
            case initiator = "Initiator"
            case isTruncated = "IsTruncated"
            case key = "Key"
            case maxParts = "MaxParts"
            case nextPartNumberMarker = "NextPartNumberMarker"
            case owner = "Owner"
            case partNumberMarker = "PartNumberMarker"
            case parts = "Part"
            case requestCharged = "x-amz-request-charged"
            case storageClass = "StorageClass"
            case uploadId = "UploadId"
        }
    }

    public struct ListPartsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "maxParts", location: .querystring(locationName: "max-parts")),
            AWSMemberEncoding(label: "partNumberMarker", location: .querystring(locationName: "part-number-marker")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "uploadId", location: .querystring(locationName: "uploadId"))
        ]

        /// The name of the bucket to which the parts are being uploaded.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Object key for which the multipart upload was initiated.
        public let key: String
        /// Sets the maximum number of parts to return.
        public let maxParts: Int?
        /// Specifies the part after which listing should begin. Only parts with higher part numbers will be listed.
        public let partNumberMarker: Int?
        public let requestPayer: RequestPayer?
        /// Upload ID identifying the multipart upload whose parts are being listed.
        public let uploadId: String

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, maxParts: Int? = nil, partNumberMarker: Int? = nil, requestPayer: RequestPayer? = nil, uploadId: String) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.maxParts = maxParts
            self.partNumberMarker = partNumberMarker
            self.requestPayer = requestPayer
            self.uploadId = uploadId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct LoggingEnabled: AWSEncodableShape & AWSDecodableShape {
        public struct _TargetGrantsEncoding: ArrayCoderProperties { public static let member = "Grant" }

        /// Specifies the bucket where you want Amazon S3 to store server access logs. You can have your logs delivered to any bucket that you own, including the same bucket that is being logged. You can also configure multiple buckets to deliver their logs to the same target bucket. In this case, you should choose a different TargetPrefix for each source bucket so that the delivered log files can be distinguished by key.
        public let targetBucket: String
        /// Container for granting information.
        @OptionalCustomCoding<ArrayCoder<_TargetGrantsEncoding, TargetGrant>>
        public var targetGrants: [TargetGrant]?
        /// A prefix for all log object keys. If you store log files from multiple Amazon S3 buckets in a single bucket, you can use a prefix to distinguish which log files came from which bucket.
        public let targetPrefix: String

        public init(targetBucket: String, targetGrants: [TargetGrant]? = nil, targetPrefix: String) {
            self.targetBucket = targetBucket
            self.targetGrants = targetGrants
            self.targetPrefix = targetPrefix
        }

        private enum CodingKeys: String, CodingKey {
            case targetBucket = "TargetBucket"
            case targetGrants = "TargetGrants"
            case targetPrefix = "TargetPrefix"
        }
    }

    public struct MetadataEntry: AWSEncodableShape {
        /// Name of the Object.
        public let name: String?
        /// Value of the Object.
        public let value: String?

        public init(name: String? = nil, value: String? = nil) {
            self.name = name
            self.value = value
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case value = "Value"
        }
    }

    public struct Metrics: AWSEncodableShape & AWSDecodableShape {
        ///  A container specifying the time threshold for emitting the s3:Replication:OperationMissedThreshold event.
        public let eventThreshold: ReplicationTimeValue?
        ///  Specifies whether the replication metrics are enabled.
        public let status: MetricsStatus

        public init(eventThreshold: ReplicationTimeValue? = nil, status: MetricsStatus) {
            self.eventThreshold = eventThreshold
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case eventThreshold = "EventThreshold"
            case status = "Status"
        }
    }

    public struct MetricsAndOperator: AWSEncodableShape & AWSDecodableShape {
        /// The prefix used when evaluating an AND predicate.
        public let prefix: String?
        /// The list of tags used when evaluating an AND predicate.
        public let tags: [Tag]?

        public init(prefix: String? = nil, tags: [Tag]? = nil) {
            self.prefix = prefix
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
            case tags = "Tag"
        }
    }

    public struct MetricsConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies a metrics configuration filter. The metrics configuration will only include objects that meet the filter's criteria. A filter must be a prefix, a tag, or a conjunction (MetricsAndOperator).
        public let filter: MetricsFilter?
        /// The ID used to identify the metrics configuration.
        public let id: String

        public init(filter: MetricsFilter? = nil, id: String) {
            self.filter = filter
            self.id = id
        }

        public func validate(name: String) throws {
            try self.filter?.validate(name: "\(name).filter")
        }

        private enum CodingKeys: String, CodingKey {
            case filter = "Filter"
            case id = "Id"
        }
    }

    public struct MetricsFilter: AWSEncodableShape & AWSDecodableShape {
        /// A conjunction (logical AND) of predicates, which is used in evaluating a metrics filter. The operator must have at least two predicates, and an object must match all of the predicates in order for the filter to apply.
        public let and: MetricsAndOperator?
        /// The prefix used when evaluating a metrics filter.
        public let prefix: String?
        /// The tag used when evaluating a metrics filter.
        public let tag: Tag?

        public init(and: MetricsAndOperator? = nil, prefix: String? = nil, tag: Tag? = nil) {
            self.and = and
            self.prefix = prefix
            self.tag = tag
        }

        public func validate(name: String) throws {
            try self.and?.validate(name: "\(name).and")
            try self.tag?.validate(name: "\(name).tag")
        }

        private enum CodingKeys: String, CodingKey {
            case and = "And"
            case prefix = "Prefix"
            case tag = "Tag"
        }
    }

    public struct MultipartUpload: AWSDecodableShape {
        /// Date and time at which the multipart upload was initiated.
        public let initiated: Date?
        /// Identifies who initiated the multipart upload.
        public let initiator: Initiator?
        /// Key of the object for which the multipart upload was initiated.
        public let key: String?
        /// Specifies the owner of the object that is part of the multipart upload.
        public let owner: Owner?
        /// The class of storage used to store the object.
        public let storageClass: StorageClass?
        /// Upload ID that identifies the multipart upload.
        public let uploadId: String?

        public init(initiated: Date? = nil, initiator: Initiator? = nil, key: String? = nil, owner: Owner? = nil, storageClass: StorageClass? = nil, uploadId: String? = nil) {
            self.initiated = initiated
            self.initiator = initiator
            self.key = key
            self.owner = owner
            self.storageClass = storageClass
            self.uploadId = uploadId
        }

        private enum CodingKeys: String, CodingKey {
            case initiated = "Initiated"
            case initiator = "Initiator"
            case key = "Key"
            case owner = "Owner"
            case storageClass = "StorageClass"
            case uploadId = "UploadId"
        }
    }

    public struct NoncurrentVersionExpiration: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the number of days an object is noncurrent before Amazon S3 can perform the associated action. For information about the noncurrent days calculations, see How Amazon S3 Calculates When an Object Became Noncurrent in the Amazon Simple Storage Service Developer Guide.
        public let noncurrentDays: Int?

        public init(noncurrentDays: Int? = nil) {
            self.noncurrentDays = noncurrentDays
        }

        private enum CodingKeys: String, CodingKey {
            case noncurrentDays = "NoncurrentDays"
        }
    }

    public struct NoncurrentVersionTransition: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the number of days an object is noncurrent before Amazon S3 can perform the associated action. For information about the noncurrent days calculations, see How Amazon S3 Calculates How Long an Object Has Been Noncurrent in the Amazon Simple Storage Service Developer Guide.
        public let noncurrentDays: Int?
        /// The class of storage used to store the object.
        public let storageClass: TransitionStorageClass?

        public init(noncurrentDays: Int? = nil, storageClass: TransitionStorageClass? = nil) {
            self.noncurrentDays = noncurrentDays
            self.storageClass = storageClass
        }

        private enum CodingKeys: String, CodingKey {
            case noncurrentDays = "NoncurrentDays"
            case storageClass = "StorageClass"
        }
    }

    public struct NotificationConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Describes the AWS Lambda functions to invoke and the events for which to invoke them.
        public let lambdaFunctionConfigurations: [LambdaFunctionConfiguration]?
        /// The Amazon Simple Queue Service queues to publish messages to and the events for which to publish messages.
        public let queueConfigurations: [QueueConfiguration]?
        /// The topic to which notifications are sent and the events for which notifications are generated.
        public let topicConfigurations: [TopicConfiguration]?

        public init(lambdaFunctionConfigurations: [LambdaFunctionConfiguration]? = nil, queueConfigurations: [QueueConfiguration]? = nil, topicConfigurations: [TopicConfiguration]? = nil) {
            self.lambdaFunctionConfigurations = lambdaFunctionConfigurations
            self.queueConfigurations = queueConfigurations
            self.topicConfigurations = topicConfigurations
        }

        private enum CodingKeys: String, CodingKey {
            case lambdaFunctionConfigurations = "CloudFunctionConfiguration"
            case queueConfigurations = "QueueConfiguration"
            case topicConfigurations = "TopicConfiguration"
        }
    }

    public struct NotificationConfigurationDeprecated: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Container for specifying the AWS Lambda notification configuration.
        public let cloudFunctionConfiguration: CloudFunctionConfiguration?
        /// This data type is deprecated. This data type specifies the configuration for publishing messages to an Amazon Simple Queue Service (Amazon SQS) queue when Amazon S3 detects specified events.
        public let queueConfiguration: QueueConfigurationDeprecated?
        /// This data type is deprecated. A container for specifying the configuration for publication of messages to an Amazon Simple Notification Service (Amazon SNS) topic when Amazon S3 detects specified events.
        public let topicConfiguration: TopicConfigurationDeprecated?

        public init(cloudFunctionConfiguration: CloudFunctionConfiguration? = nil, queueConfiguration: QueueConfigurationDeprecated? = nil, topicConfiguration: TopicConfigurationDeprecated? = nil) {
            self.cloudFunctionConfiguration = cloudFunctionConfiguration
            self.queueConfiguration = queueConfiguration
            self.topicConfiguration = topicConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case cloudFunctionConfiguration = "CloudFunctionConfiguration"
            case queueConfiguration = "QueueConfiguration"
            case topicConfiguration = "TopicConfiguration"
        }
    }

    public struct NotificationConfigurationFilter: AWSEncodableShape & AWSDecodableShape {
        public let key: S3KeyFilter?

        public init(key: S3KeyFilter? = nil) {
            self.key = key
        }

        private enum CodingKeys: String, CodingKey {
            case key = "S3Key"
        }
    }

    public struct Object: AWSDecodableShape {
        /// The entity tag is a hash of the object. The ETag reflects changes only to the contents of an object, not its metadata. The ETag may or may not be an MD5 digest of the object data. Whether or not it is depends on how the object was created and how it is encrypted as described below:   Objects created by the PUT Object, POST Object, or Copy operation, or through the AWS Management Console, and are encrypted by SSE-S3 or plaintext, have ETags that are an MD5 digest of their object data.   Objects created by the PUT Object, POST Object, or Copy operation, or through the AWS Management Console, and are encrypted by SSE-C or SSE-KMS, have ETags that are not an MD5 digest of their object data.   If an object is created by either the Multipart Upload or Part Copy operation, the ETag is not an MD5 digest, regardless of the method of encryption.
        public let eTag: String?
        /// The name that you assign to an object. You use the object key to retrieve the object.
        public let key: String?
        /// Creation date of the object.
        public let lastModified: Date?
        /// The owner of the object
        public let owner: Owner?
        /// Size in bytes of the object
        public let size: Int64?
        /// The class of storage used to store the object.
        public let storageClass: ObjectStorageClass?

        public init(eTag: String? = nil, key: String? = nil, lastModified: Date? = nil, owner: Owner? = nil, size: Int64? = nil, storageClass: ObjectStorageClass? = nil) {
            self.eTag = eTag
            self.key = key
            self.lastModified = lastModified
            self.owner = owner
            self.size = size
            self.storageClass = storageClass
        }

        private enum CodingKeys: String, CodingKey {
            case eTag = "ETag"
            case key = "Key"
            case lastModified = "LastModified"
            case owner = "Owner"
            case size = "Size"
            case storageClass = "StorageClass"
        }
    }

    public struct ObjectIdentifier: AWSEncodableShape {
        /// Key name of the object.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let key: String
        /// VersionId for the specific version of the object to delete.
        public let versionId: String?

        public init(key: String, versionId: String? = nil) {
            self.key = key
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
            case versionId = "VersionId"
        }
    }

    public struct ObjectLockConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Indicates whether this bucket has an Object Lock configuration enabled.
        public let objectLockEnabled: ObjectLockEnabled?
        /// The Object Lock rule in place for the specified object.
        public let rule: ObjectLockRule?

        public init(objectLockEnabled: ObjectLockEnabled? = nil, rule: ObjectLockRule? = nil) {
            self.objectLockEnabled = objectLockEnabled
            self.rule = rule
        }

        private enum CodingKeys: String, CodingKey {
            case objectLockEnabled = "ObjectLockEnabled"
            case rule = "Rule"
        }
    }

    public struct ObjectLockLegalHold: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Indicates whether the specified object has a Legal Hold in place.
        public let status: ObjectLockLegalHoldStatus?

        public init(status: ObjectLockLegalHoldStatus? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct ObjectLockRetention: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Indicates the Retention mode for the specified object.
        public let mode: ObjectLockRetentionMode?
        /// The date on which this Object Lock Retention will expire.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var retainUntilDate: Date?

        public init(mode: ObjectLockRetentionMode? = nil, retainUntilDate: Date? = nil) {
            self.mode = mode
            self.retainUntilDate = retainUntilDate
        }

        private enum CodingKeys: String, CodingKey {
            case mode = "Mode"
            case retainUntilDate = "RetainUntilDate"
        }
    }

    public struct ObjectLockRule: AWSEncodableShape & AWSDecodableShape {
        /// The default retention period that you want to apply to new objects placed in the specified bucket.
        public let defaultRetention: DefaultRetention?

        public init(defaultRetention: DefaultRetention? = nil) {
            self.defaultRetention = defaultRetention
        }

        private enum CodingKeys: String, CodingKey {
            case defaultRetention = "DefaultRetention"
        }
    }

    public struct ObjectVersion: AWSDecodableShape {
        /// The entity tag is an MD5 hash of that version of the object.
        public let eTag: String?
        /// Specifies whether the object is (true) or is not (false) the latest version of an object.
        public let isLatest: Bool?
        /// The object key.
        public let key: String?
        /// Date and time the object was last modified.
        public let lastModified: Date?
        /// Specifies the owner of the object.
        public let owner: Owner?
        /// Size in bytes of the object.
        public let size: Int64?
        /// The class of storage used to store the object.
        public let storageClass: ObjectVersionStorageClass?
        /// Version ID of an object.
        public let versionId: String?

        public init(eTag: String? = nil, isLatest: Bool? = nil, key: String? = nil, lastModified: Date? = nil, owner: Owner? = nil, size: Int64? = nil, storageClass: ObjectVersionStorageClass? = nil, versionId: String? = nil) {
            self.eTag = eTag
            self.isLatest = isLatest
            self.key = key
            self.lastModified = lastModified
            self.owner = owner
            self.size = size
            self.storageClass = storageClass
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case eTag = "ETag"
            case isLatest = "IsLatest"
            case key = "Key"
            case lastModified = "LastModified"
            case owner = "Owner"
            case size = "Size"
            case storageClass = "StorageClass"
            case versionId = "VersionId"
        }
    }

    public struct OutputLocation: AWSEncodableShape {
        /// Describes an S3 location that will receive the results of the restore request.
        public let s3: S3Location?

        public init(s3: S3Location? = nil) {
            self.s3 = s3
        }

        public func validate(name: String) throws {
            try self.s3?.validate(name: "\(name).s3")
        }

        private enum CodingKeys: String, CodingKey {
            case s3 = "S3"
        }
    }

    public struct OutputSerialization: AWSEncodableShape {
        /// Describes the serialization of CSV-encoded Select results.
        public let csv: CSVOutput?
        /// Specifies JSON as request's output serialization format.
        public let json: JSONOutput?

        public init(csv: CSVOutput? = nil, json: JSONOutput? = nil) {
            self.csv = csv
            self.json = json
        }

        private enum CodingKeys: String, CodingKey {
            case csv = "CSV"
            case json = "JSON"
        }
    }

    public struct Owner: AWSEncodableShape & AWSDecodableShape {
        /// Container for the display name of the owner.
        public let displayName: String?
        /// Container for the ID of the owner.
        public let id: String?

        public init(displayName: String? = nil, id: String? = nil) {
            self.displayName = displayName
            self.id = id
        }

        private enum CodingKeys: String, CodingKey {
            case displayName = "DisplayName"
            case id = "ID"
        }
    }

    public struct OwnershipControls: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// The container element for an ownership control rule.
        public let rules: [OwnershipControlsRule]

        public init(rules: [OwnershipControlsRule]) {
            self.rules = rules
        }

        private enum CodingKeys: String, CodingKey {
            case rules = "Rule"
        }
    }

    public struct OwnershipControlsRule: AWSEncodableShape & AWSDecodableShape {
        public let objectOwnership: ObjectOwnership

        public init(objectOwnership: ObjectOwnership) {
            self.objectOwnership = objectOwnership
        }

        private enum CodingKeys: String, CodingKey {
            case objectOwnership = "ObjectOwnership"
        }
    }

    public struct ParquetInput: AWSEncodableShape {
        public init() {}
    }

    public struct Part: AWSDecodableShape {
        /// Entity tag returned when the part was uploaded.
        public let eTag: String?
        /// Date and time at which the part was uploaded.
        public let lastModified: Date?
        /// Part number identifying the part. This is a positive integer between 1 and 10,000.
        public let partNumber: Int?
        /// Size in bytes of the uploaded part data.
        public let size: Int64?

        public init(eTag: String? = nil, lastModified: Date? = nil, partNumber: Int? = nil, size: Int64? = nil) {
            self.eTag = eTag
            self.lastModified = lastModified
            self.partNumber = partNumber
            self.size = size
        }

        private enum CodingKeys: String, CodingKey {
            case eTag = "ETag"
            case lastModified = "LastModified"
            case partNumber = "PartNumber"
            case size = "Size"
        }
    }

    public struct PolicyStatus: AWSDecodableShape {
        /// The policy status for this bucket. TRUE indicates that this bucket is public. FALSE indicates that the bucket is not public.
        public let isPublic: Bool?

        public init(isPublic: Bool? = nil) {
            self.isPublic = isPublic
        }

        private enum CodingKeys: String, CodingKey {
            case isPublic = "IsPublic"
        }
    }

    public struct Progress: AWSDecodableShape {
        /// The current number of uncompressed object bytes processed.
        public let bytesProcessed: Int64?
        /// The current number of bytes of records payload data returned.
        public let bytesReturned: Int64?
        /// The current number of object bytes scanned.
        public let bytesScanned: Int64?

        public init(bytesProcessed: Int64? = nil, bytesReturned: Int64? = nil, bytesScanned: Int64? = nil) {
            self.bytesProcessed = bytesProcessed
            self.bytesReturned = bytesReturned
            self.bytesScanned = bytesScanned
        }

        private enum CodingKeys: String, CodingKey {
            case bytesProcessed = "BytesProcessed"
            case bytesReturned = "BytesReturned"
            case bytesScanned = "BytesScanned"
        }
    }

    public struct ProgressEvent: AWSDecodableShape {
        /// The Progress event details.
        public let details: Progress?

        public init(details: Progress? = nil) {
            self.details = details
        }

        private enum CodingKeys: String, CodingKey {
            case details = "Details"
        }
    }

    public struct PublicAccessBlockConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies whether Amazon S3 should block public access control lists (ACLs) for this bucket and objects in this bucket. Setting this element to TRUE causes the following behavior:   PUT Bucket acl and PUT Object acl calls fail if the specified ACL is public.   PUT Object calls fail if the request includes a public ACL.   PUT Bucket calls fail if the request includes a public ACL.   Enabling this setting doesn't affect existing policies or ACLs.
        public let blockPublicAcls: Bool?
        /// Specifies whether Amazon S3 should block public bucket policies for this bucket. Setting this element to TRUE causes Amazon S3 to reject calls to PUT Bucket policy if the specified bucket policy allows public access.  Enabling this setting doesn't affect existing bucket policies.
        public let blockPublicPolicy: Bool?
        /// Specifies whether Amazon S3 should ignore public ACLs for this bucket and objects in this bucket. Setting this element to TRUE causes Amazon S3 to ignore all public ACLs on this bucket and objects in this bucket. Enabling this setting doesn't affect the persistence of any existing ACLs and doesn't prevent new public ACLs from being set.
        public let ignorePublicAcls: Bool?
        /// Specifies whether Amazon S3 should restrict public bucket policies for this bucket. Setting this element to TRUE restricts access to this bucket to only AWS service principals and authorized users within this account if the bucket has a public policy. Enabling this setting doesn't affect previously stored bucket policies, except that public and cross-account access within any public bucket policy, including non-public delegation to specific accounts, is blocked.
        public let restrictPublicBuckets: Bool?

        public init(blockPublicAcls: Bool? = nil, blockPublicPolicy: Bool? = nil, ignorePublicAcls: Bool? = nil, restrictPublicBuckets: Bool? = nil) {
            self.blockPublicAcls = blockPublicAcls
            self.blockPublicPolicy = blockPublicPolicy
            self.ignorePublicAcls = ignorePublicAcls
            self.restrictPublicBuckets = restrictPublicBuckets
        }

        private enum CodingKeys: String, CodingKey {
            case blockPublicAcls = "BlockPublicAcls"
            case blockPublicPolicy = "BlockPublicPolicy"
            case ignorePublicAcls = "IgnorePublicAcls"
            case restrictPublicBuckets = "RestrictPublicBuckets"
        }
    }

    public struct PutBucketAccelerateConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "accelerateConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "accelerateConfiguration", location: .body(locationName: "AccelerateConfiguration")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// Container for setting the transfer acceleration state.
        public let accelerateConfiguration: AccelerateConfiguration
        /// The name of the bucket for which the accelerate configuration is set.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(accelerateConfiguration: AccelerateConfiguration, bucket: String, expectedBucketOwner: String? = nil) {
            self.accelerateConfiguration = accelerateConfiguration
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: String, CodingKey {
            case accelerateConfiguration = "AccelerateConfiguration"
        }
    }

    public struct PutBucketAclRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "accessControlPolicy"
        public static var _encoding = [
            AWSMemberEncoding(label: "accessControlPolicy", location: .body(locationName: "AccessControlPolicy")),
            AWSMemberEncoding(label: "acl", location: .header(locationName: "x-amz-acl")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "grantFullControl", location: .header(locationName: "x-amz-grant-full-control")),
            AWSMemberEncoding(label: "grantRead", location: .header(locationName: "x-amz-grant-read")),
            AWSMemberEncoding(label: "grantReadACP", location: .header(locationName: "x-amz-grant-read-acp")),
            AWSMemberEncoding(label: "grantWrite", location: .header(locationName: "x-amz-grant-write")),
            AWSMemberEncoding(label: "grantWriteACP", location: .header(locationName: "x-amz-grant-write-acp"))
        ]

        /// Contains the elements that set the ACL permissions for an object per grantee.
        public let accessControlPolicy: AccessControlPolicy?
        /// The canned ACL to apply to the bucket.
        public let acl: BucketCannedACL?
        /// The bucket to which to apply the ACL.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. This header must be used as a message integrity check to verify that the request body was not corrupted in transit. For more information, go to RFC 1864.  For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Allows grantee the read, write, read ACP, and write ACP permissions on the bucket.
        public let grantFullControl: String?
        /// Allows grantee to list the objects in the bucket.
        public let grantRead: String?
        /// Allows grantee to read the bucket ACL.
        public let grantReadACP: String?
        /// Allows grantee to create, overwrite, and delete any object in the bucket.
        public let grantWrite: String?
        /// Allows grantee to write the ACL for the applicable bucket.
        public let grantWriteACP: String?

        public init(accessControlPolicy: AccessControlPolicy? = nil, acl: BucketCannedACL? = nil, bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, grantFullControl: String? = nil, grantRead: String? = nil, grantReadACP: String? = nil, grantWrite: String? = nil, grantWriteACP: String? = nil) {
            self.accessControlPolicy = accessControlPolicy
            self.acl = acl
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.grantFullControl = grantFullControl
            self.grantRead = grantRead
            self.grantReadACP = grantReadACP
            self.grantWrite = grantWrite
            self.grantWriteACP = grantWriteACP
        }

        private enum CodingKeys: String, CodingKey {
            case accessControlPolicy = "AccessControlPolicy"
        }
    }

    public struct PutBucketAnalyticsConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "analyticsConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "analyticsConfiguration", location: .body(locationName: "AnalyticsConfiguration")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id"))
        ]

        /// The configuration and any analyses for the analytics filter.
        public let analyticsConfiguration: AnalyticsConfiguration
        /// The name of the bucket to which an analytics configuration is stored.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID that identifies the analytics configuration.
        public let id: String

        public init(analyticsConfiguration: AnalyticsConfiguration, bucket: String, expectedBucketOwner: String? = nil, id: String) {
            self.analyticsConfiguration = analyticsConfiguration
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
        }

        public func validate(name: String) throws {
            try self.analyticsConfiguration.validate(name: "\(name).analyticsConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case analyticsConfiguration = "AnalyticsConfiguration"
        }
    }

    public struct PutBucketCorsRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "cORSConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "cORSConfiguration", location: .body(locationName: "CORSConfiguration")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// Specifies the bucket impacted by the corsconfiguration.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. This header must be used as a message integrity check to verify that the request body was not corrupted in transit. For more information, go to RFC 1864.  For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// Describes the cross-origin access configuration for objects in an Amazon S3 bucket. For more information, see Enabling Cross-Origin Resource Sharing in the Amazon Simple Storage Service Developer Guide.
        public let cORSConfiguration: CORSConfiguration
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, contentMD5: String? = nil, cORSConfiguration: CORSConfiguration, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.cORSConfiguration = cORSConfiguration
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: String, CodingKey {
            case cORSConfiguration = "CORSConfiguration"
        }
    }

    public struct PutBucketEncryptionRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "serverSideEncryptionConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "serverSideEncryptionConfiguration", location: .body(locationName: "ServerSideEncryptionConfiguration"))
        ]

        /// Specifies default encryption for a bucket using server-side encryption with Amazon S3-managed keys (SSE-S3) or customer master keys stored in AWS KMS (SSE-KMS). For information about the Amazon S3 default encryption feature, see Amazon S3 Default Bucket Encryption in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the server-side encryption configuration. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        public let serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, serverSideEncryptionConfiguration: ServerSideEncryptionConfiguration) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.serverSideEncryptionConfiguration = serverSideEncryptionConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case serverSideEncryptionConfiguration = "ServerSideEncryptionConfiguration"
        }
    }

    public struct PutBucketIntelligentTieringConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "intelligentTieringConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id")),
            AWSMemberEncoding(label: "intelligentTieringConfiguration", location: .body(locationName: "IntelligentTieringConfiguration"))
        ]

        /// The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.
        public let bucket: String
        /// The ID used to identify the S3 Intelligent-Tiering configuration.
        public let id: String
        /// Container for S3 Intelligent-Tiering configuration.
        public let intelligentTieringConfiguration: IntelligentTieringConfiguration

        public init(bucket: String, id: String, intelligentTieringConfiguration: IntelligentTieringConfiguration) {
            self.bucket = bucket
            self.id = id
            self.intelligentTieringConfiguration = intelligentTieringConfiguration
        }

        public func validate(name: String) throws {
            try self.intelligentTieringConfiguration.validate(name: "\(name).intelligentTieringConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case intelligentTieringConfiguration = "IntelligentTieringConfiguration"
        }
    }

    public struct PutBucketInventoryConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "inventoryConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id")),
            AWSMemberEncoding(label: "inventoryConfiguration", location: .body(locationName: "InventoryConfiguration"))
        ]

        /// The name of the bucket where the inventory configuration will be stored.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID used to identify the inventory configuration.
        public let id: String
        /// Specifies the inventory configuration.
        public let inventoryConfiguration: InventoryConfiguration

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String, inventoryConfiguration: InventoryConfiguration) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
            self.inventoryConfiguration = inventoryConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case inventoryConfiguration = "InventoryConfiguration"
        }
    }

    public struct PutBucketLifecycleConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "lifecycleConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "lifecycleConfiguration", location: .body(locationName: "LifecycleConfiguration"))
        ]

        /// The name of the bucket for which to set the configuration.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Container for lifecycle rules. You can add as many as 1,000 rules.
        public let lifecycleConfiguration: BucketLifecycleConfiguration?

        public init(bucket: String, expectedBucketOwner: String? = nil, lifecycleConfiguration: BucketLifecycleConfiguration? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.lifecycleConfiguration = lifecycleConfiguration
        }

        public func validate(name: String) throws {
            try self.lifecycleConfiguration?.validate(name: "\(name).lifecycleConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case lifecycleConfiguration = "LifecycleConfiguration"
        }
    }

    public struct PutBucketLifecycleRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "lifecycleConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "lifecycleConfiguration", location: .body(locationName: "LifecycleConfiguration"))
        ]

        public let bucket: String
        ///  For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        public let lifecycleConfiguration: LifecycleConfiguration?

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, lifecycleConfiguration: LifecycleConfiguration? = nil) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.lifecycleConfiguration = lifecycleConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case lifecycleConfiguration = "LifecycleConfiguration"
        }
    }

    public struct PutBucketLoggingRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "bucketLoggingStatus"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bucketLoggingStatus", location: .body(locationName: "BucketLoggingStatus")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner"))
        ]

        /// The name of the bucket for which to set the logging parameters.
        public let bucket: String
        /// Container for logging status information.
        public let bucketLoggingStatus: BucketLoggingStatus
        /// The MD5 hash of the PutBucketLogging request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?

        public init(bucket: String, bucketLoggingStatus: BucketLoggingStatus, contentMD5: String? = nil, expectedBucketOwner: String? = nil) {
            self.bucket = bucket
            self.bucketLoggingStatus = bucketLoggingStatus
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
        }

        private enum CodingKeys: String, CodingKey {
            case bucketLoggingStatus = "BucketLoggingStatus"
        }
    }

    public struct PutBucketMetricsConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "metricsConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "id", location: .querystring(locationName: "id")),
            AWSMemberEncoding(label: "metricsConfiguration", location: .body(locationName: "MetricsConfiguration"))
        ]

        /// The name of the bucket for which the metrics configuration is set.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The ID used to identify the metrics configuration.
        public let id: String
        /// Specifies the metrics configuration.
        public let metricsConfiguration: MetricsConfiguration

        public init(bucket: String, expectedBucketOwner: String? = nil, id: String, metricsConfiguration: MetricsConfiguration) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.id = id
            self.metricsConfiguration = metricsConfiguration
        }

        public func validate(name: String) throws {
            try self.metricsConfiguration.validate(name: "\(name).metricsConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case metricsConfiguration = "MetricsConfiguration"
        }
    }

    public struct PutBucketNotificationConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "notificationConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "notificationConfiguration", location: .body(locationName: "NotificationConfiguration"))
        ]

        /// The name of the bucket.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        public let notificationConfiguration: NotificationConfiguration

        public init(bucket: String, expectedBucketOwner: String? = nil, notificationConfiguration: NotificationConfiguration) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.notificationConfiguration = notificationConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case notificationConfiguration = "NotificationConfiguration"
        }
    }

    public struct PutBucketNotificationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "notificationConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "notificationConfiguration", location: .body(locationName: "NotificationConfiguration"))
        ]

        /// The name of the bucket.
        public let bucket: String
        /// The MD5 hash of the PutPublicAccessBlock request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The container for the configuration.
        public let notificationConfiguration: NotificationConfigurationDeprecated

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, notificationConfiguration: NotificationConfigurationDeprecated) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.notificationConfiguration = notificationConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case notificationConfiguration = "NotificationConfiguration"
        }
    }

    public struct PutBucketOwnershipControlsRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "ownershipControls"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "ownershipControls", location: .body(locationName: "OwnershipControls"))
        ]

        /// The name of the Amazon S3 bucket whose OwnershipControls you want to set.
        public let bucket: String
        /// The MD5 hash of the OwnershipControls request body.  For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The OwnershipControls (BucketOwnerPreferred or ObjectWriter) that you want to apply to this Amazon S3 bucket.
        public let ownershipControls: OwnershipControls

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, ownershipControls: OwnershipControls) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.ownershipControls = ownershipControls
        }

        private enum CodingKeys: String, CodingKey {
            case ownershipControls = "OwnershipControls"
        }
    }

    public struct PutBucketPolicyRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "policy"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "confirmRemoveSelfBucketAccess", location: .header(locationName: "x-amz-confirm-remove-self-bucket-access")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "policy", location: .body(locationName: "Policy"))
        ]

        /// The name of the bucket.
        public let bucket: String
        /// Set this parameter to true to confirm that you want to remove your permissions to change this bucket policy in the future.
        public let confirmRemoveSelfBucketAccess: Bool?
        /// The MD5 hash of the request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The bucket policy as a JSON document.
        public let policy: String

        public init(bucket: String, confirmRemoveSelfBucketAccess: Bool? = nil, contentMD5: String? = nil, expectedBucketOwner: String? = nil, policy: String) {
            self.bucket = bucket
            self.confirmRemoveSelfBucketAccess = confirmRemoveSelfBucketAccess
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.policy = policy
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
        }
    }

    public struct PutBucketReplicationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "replicationConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "replicationConfiguration", location: .body(locationName: "ReplicationConfiguration")),
            AWSMemberEncoding(label: "token", location: .header(locationName: "x-amz-bucket-object-lock-token"))
        ]

        /// The name of the bucket
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. You must use this header as a message integrity check to verify that the request body was not corrupted in transit. For more information, see RFC 1864. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        public let replicationConfiguration: ReplicationConfiguration
        /// A token to allow Object Lock to be enabled for an existing bucket.
        public let token: String?

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, replicationConfiguration: ReplicationConfiguration, token: String? = nil) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.replicationConfiguration = replicationConfiguration
            self.token = token
        }

        public func validate(name: String) throws {
            try self.replicationConfiguration.validate(name: "\(name).replicationConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case replicationConfiguration = "ReplicationConfiguration"
        }
    }

    public struct PutBucketRequestPaymentRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "requestPaymentConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "requestPaymentConfiguration", location: .body(locationName: "RequestPaymentConfiguration"))
        ]

        /// The bucket name.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. You must use this header as a message integrity check to verify that the request body was not corrupted in transit. For more information, see RFC 1864. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Container for Payer.
        public let requestPaymentConfiguration: RequestPaymentConfiguration

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, requestPaymentConfiguration: RequestPaymentConfiguration) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.requestPaymentConfiguration = requestPaymentConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case requestPaymentConfiguration = "RequestPaymentConfiguration"
        }
    }

    public struct PutBucketTaggingRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "tagging"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "tagging", location: .body(locationName: "Tagging"))
        ]

        /// The bucket name.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. You must use this header as a message integrity check to verify that the request body was not corrupted in transit. For more information, see RFC 1864. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Container for the TagSet and Tag elements.
        public let tagging: Tagging

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, tagging: Tagging) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.tagging = tagging
        }

        public func validate(name: String) throws {
            try self.tagging.validate(name: "\(name).tagging")
        }

        private enum CodingKeys: String, CodingKey {
            case tagging = "Tagging"
        }
    }

    public struct PutBucketVersioningRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "versioningConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "mfa", location: .header(locationName: "x-amz-mfa")),
            AWSMemberEncoding(label: "versioningConfiguration", location: .body(locationName: "VersioningConfiguration"))
        ]

        /// The bucket name.
        public let bucket: String
        /// &gt;The base64-encoded 128-bit MD5 digest of the data. You must use this header as a message integrity check to verify that the request body was not corrupted in transit. For more information, see RFC 1864. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The concatenation of the authentication device's serial number, a space, and the value that is displayed on your authentication device.
        public let mfa: String?
        /// Container for setting the versioning state.
        public let versioningConfiguration: VersioningConfiguration

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, mfa: String? = nil, versioningConfiguration: VersioningConfiguration) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.mfa = mfa
            self.versioningConfiguration = versioningConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case versioningConfiguration = "VersioningConfiguration"
        }
    }

    public struct PutBucketWebsiteRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "websiteConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "websiteConfiguration", location: .body(locationName: "WebsiteConfiguration"))
        ]

        /// The bucket name.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. You must use this header as a message integrity check to verify that the request body was not corrupted in transit. For more information, see RFC 1864. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Container for the request.
        public let websiteConfiguration: WebsiteConfiguration

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, websiteConfiguration: WebsiteConfiguration) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.websiteConfiguration = websiteConfiguration
        }

        public func validate(name: String) throws {
            try self.websiteConfiguration.validate(name: "\(name).websiteConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case websiteConfiguration = "WebsiteConfiguration"
        }
    }

    public struct PutObjectAclOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        public let requestCharged: RequestCharged?

        public init(requestCharged: RequestCharged? = nil) {
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct PutObjectAclRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "accessControlPolicy"
        public static var _encoding = [
            AWSMemberEncoding(label: "accessControlPolicy", location: .body(locationName: "AccessControlPolicy")),
            AWSMemberEncoding(label: "acl", location: .header(locationName: "x-amz-acl")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "grantFullControl", location: .header(locationName: "x-amz-grant-full-control")),
            AWSMemberEncoding(label: "grantRead", location: .header(locationName: "x-amz-grant-read")),
            AWSMemberEncoding(label: "grantReadACP", location: .header(locationName: "x-amz-grant-read-acp")),
            AWSMemberEncoding(label: "grantWrite", location: .header(locationName: "x-amz-grant-write")),
            AWSMemberEncoding(label: "grantWriteACP", location: .header(locationName: "x-amz-grant-write-acp")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// Contains the elements that set the ACL permissions for an object per grantee.
        public let accessControlPolicy: AccessControlPolicy?
        /// The canned ACL to apply to the object. For more information, see Canned ACL.
        public let acl: ObjectCannedACL?
        /// The bucket name that contains the object to which you want to attach the ACL.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The base64-encoded 128-bit MD5 digest of the data. This header must be used as a message integrity check to verify that the request body was not corrupted in transit. For more information, go to RFC 1864.&gt;  For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Allows grantee the read, write, read ACP, and write ACP permissions on the bucket. This action is not supported by Amazon S3 on Outposts.
        public let grantFullControl: String?
        /// Allows grantee to list the objects in the bucket. This action is not supported by Amazon S3 on Outposts.
        public let grantRead: String?
        /// Allows grantee to read the bucket ACL. This action is not supported by Amazon S3 on Outposts.
        public let grantReadACP: String?
        /// Allows grantee to create, overwrite, and delete any object in the bucket.
        public let grantWrite: String?
        /// Allows grantee to write the ACL for the applicable bucket. This action is not supported by Amazon S3 on Outposts.
        public let grantWriteACP: String?
        /// Key for which the PUT operation was initiated. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let key: String
        public let requestPayer: RequestPayer?
        /// VersionId used to reference a specific version of the object.
        public let versionId: String?

        public init(accessControlPolicy: AccessControlPolicy? = nil, acl: ObjectCannedACL? = nil, bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, grantFullControl: String? = nil, grantRead: String? = nil, grantReadACP: String? = nil, grantWrite: String? = nil, grantWriteACP: String? = nil, key: String, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.accessControlPolicy = accessControlPolicy
            self.acl = acl
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.grantFullControl = grantFullControl
            self.grantRead = grantRead
            self.grantReadACP = grantReadACP
            self.grantWrite = grantWrite
            self.grantWriteACP = grantWriteACP
            self.key = key
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case accessControlPolicy = "AccessControlPolicy"
        }
    }

    public struct PutObjectLegalHoldOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        public let requestCharged: RequestCharged?

        public init(requestCharged: RequestCharged? = nil) {
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct PutObjectLegalHoldRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "legalHold"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "legalHold", location: .body(locationName: "LegalHold")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object that you want to place a Legal Hold on.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The MD5 hash for the request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The key name for the object that you want to place a Legal Hold on.
        public let key: String
        /// Container element for the Legal Hold configuration you want to apply to the specified object.
        public let legalHold: ObjectLockLegalHold?
        public let requestPayer: RequestPayer?
        /// The version ID of the object that you want to place a Legal Hold on.
        public let versionId: String?

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, key: String, legalHold: ObjectLockLegalHold? = nil, requestPayer: RequestPayer? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.legalHold = legalHold
            self.requestPayer = requestPayer
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case legalHold = "LegalHold"
        }
    }

    public struct PutObjectLockConfigurationOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        public let requestCharged: RequestCharged?

        public init(requestCharged: RequestCharged? = nil) {
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct PutObjectLockConfigurationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "objectLockConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "objectLockConfiguration", location: .body(locationName: "ObjectLockConfiguration")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "token", location: .header(locationName: "x-amz-bucket-object-lock-token"))
        ]

        /// The bucket whose Object Lock configuration you want to create or replace.
        public let bucket: String
        /// The MD5 hash for the request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The Object Lock configuration that you want to apply to the specified bucket.
        public let objectLockConfiguration: ObjectLockConfiguration?
        public let requestPayer: RequestPayer?
        /// A token to allow Object Lock to be enabled for an existing bucket.
        public let token: String?

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, objectLockConfiguration: ObjectLockConfiguration? = nil, requestPayer: RequestPayer? = nil, token: String? = nil) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.objectLockConfiguration = objectLockConfiguration
            self.requestPayer = requestPayer
            self.token = token
        }

        private enum CodingKeys: String, CodingKey {
            case objectLockConfiguration = "ObjectLockConfiguration"
        }
    }

    public struct PutObjectOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "eTag", location: .header(locationName: "ETag")),
            AWSMemberEncoding(label: "expiration", location: .header(locationName: "x-amz-expiration")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSEncryptionContext", location: .header(locationName: "x-amz-server-side-encryption-context")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]

        /// Indicates whether the uploaded object uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Entity tag for the uploaded object.
        public let eTag: String?
        ///  If the expiration is configured for the object (see PutBucketLifecycleConfiguration), the response includes this header. It includes the expiry-date and rule-id key-value pairs that provide information about object expiration. The value of the rule-id is URL encoded.
        public let expiration: String?
        public let requestCharged: RequestCharged?
        /// If you specified server-side encryption either with an AWS KMS customer master key (CMK) or Amazon S3-managed encryption key in your PUT request, the response includes this header. It confirms the encryption algorithm that Amazon S3 used to encrypt the object.
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the AWS KMS Encryption Context to use for object encryption. The value of this header is a base64-encoded UTF-8 string holding JSON with the encryption context key-value pairs.
        public let sSEKMSEncryptionContext: String?
        /// If x-amz-server-side-encryption is present and has the value of aws:kms, this header specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?
        /// Version of the object.
        public let versionId: String?

        public init(bucketKeyEnabled: Bool? = nil, eTag: String? = nil, expiration: String? = nil, requestCharged: RequestCharged? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSEncryptionContext: String? = nil, sSEKMSKeyId: String? = nil, versionId: String? = nil) {
            self.bucketKeyEnabled = bucketKeyEnabled
            self.eTag = eTag
            self.expiration = expiration
            self.requestCharged = requestCharged
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSEncryptionContext = sSEKMSEncryptionContext
            self.sSEKMSKeyId = sSEKMSKeyId
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case eTag = "ETag"
            case expiration = "x-amz-expiration"
            case requestCharged = "x-amz-request-charged"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSEncryptionContext = "x-amz-server-side-encryption-context"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
            case versionId = "x-amz-version-id"
        }
    }

    public struct PutObjectRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "body"
        public static let _payloadOptions: AWSShapePayloadOptions = [.raw, .allowStreaming]
        public static var _encoding = [
            AWSMemberEncoding(label: "acl", location: .header(locationName: "x-amz-acl")),
            AWSMemberEncoding(label: "body", location: .body(locationName: "Body")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "cacheControl", location: .header(locationName: "Cache-Control")),
            AWSMemberEncoding(label: "contentDisposition", location: .header(locationName: "Content-Disposition")),
            AWSMemberEncoding(label: "contentEncoding", location: .header(locationName: "Content-Encoding")),
            AWSMemberEncoding(label: "contentLanguage", location: .header(locationName: "Content-Language")),
            AWSMemberEncoding(label: "contentLength", location: .header(locationName: "Content-Length")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "contentType", location: .header(locationName: "Content-Type")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "_expires", location: .header(locationName: "Expires")),
            AWSMemberEncoding(label: "grantFullControl", location: .header(locationName: "x-amz-grant-full-control")),
            AWSMemberEncoding(label: "grantRead", location: .header(locationName: "x-amz-grant-read")),
            AWSMemberEncoding(label: "grantReadACP", location: .header(locationName: "x-amz-grant-read-acp")),
            AWSMemberEncoding(label: "grantWriteACP", location: .header(locationName: "x-amz-grant-write-acp")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "metadata", location: .header(locationName: "x-amz-meta-")),
            AWSMemberEncoding(label: "objectLockLegalHoldStatus", location: .header(locationName: "x-amz-object-lock-legal-hold")),
            AWSMemberEncoding(label: "objectLockMode", location: .header(locationName: "x-amz-object-lock-mode")),
            AWSMemberEncoding(label: "_objectLockRetainUntilDate", location: .header(locationName: "x-amz-object-lock-retain-until-date")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSEncryptionContext", location: .header(locationName: "x-amz-server-side-encryption-context")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id")),
            AWSMemberEncoding(label: "storageClass", location: .header(locationName: "x-amz-storage-class")),
            AWSMemberEncoding(label: "tagging", location: .header(locationName: "x-amz-tagging")),
            AWSMemberEncoding(label: "websiteRedirectLocation", location: .header(locationName: "x-amz-website-redirect-location"))
        ]

        /// The canned ACL to apply to the object. For more information, see Canned ACL. This action is not supported by Amazon S3 on Outposts.
        public let acl: ObjectCannedACL?
        /// Object data.
        public let body: AWSPayload?
        /// The bucket name to which the PUT operation was initiated.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption with server-side encryption using AWS KMS (SSE-KMS). Setting this header to true causes Amazon S3 to use an S3 Bucket Key for object encryption with SSE-KMS. Specifying this header with a PUT operation doesn’t affect bucket-level settings for S3 Bucket Key.
        public let bucketKeyEnabled: Bool?
        ///  Can be used to specify caching behavior along the request/reply chain. For more information, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.
        public let cacheControl: String?
        /// Specifies presentational information for the object. For more information, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html#sec19.5.1.
        public let contentDisposition: String?
        /// Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field. For more information, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11.
        public let contentEncoding: String?
        /// The language the content is in.
        public let contentLanguage: String?
        /// Size of the body in bytes. This parameter is useful when the size of the body cannot be determined automatically. For more information, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.13.
        public let contentLength: Int64?
        /// The base64-encoded 128-bit MD5 digest of the message (without the headers) according to RFC 1864. This header can be used as a message integrity check to verify that the data is the same data that was originally sent. Although it is optional, we recommend using the Content-MD5 mechanism as an end-to-end integrity check. For more information about REST request authentication, see REST Authentication.
        public let contentMD5: String?
        /// A standard MIME type describing the format of the contents. For more information, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17.
        public let contentType: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The date and time at which the object is no longer cacheable. For more information, see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.21.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var expires: Date?
        /// Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object. This action is not supported by Amazon S3 on Outposts.
        public let grantFullControl: String?
        /// Allows grantee to read the object data and its metadata. This action is not supported by Amazon S3 on Outposts.
        public let grantRead: String?
        /// Allows grantee to read the object ACL. This action is not supported by Amazon S3 on Outposts.
        public let grantReadACP: String?
        /// Allows grantee to write the ACL for the applicable object. This action is not supported by Amazon S3 on Outposts.
        public let grantWriteACP: String?
        /// Object key for which the PUT operation was initiated.
        public let key: String
        /// A map of metadata to store with the object in S3.
        public let metadata: [String: String]?
        /// Specifies whether a legal hold will be applied to this object. For more information about S3 Object Lock, see Object Lock.
        public let objectLockLegalHoldStatus: ObjectLockLegalHoldStatus?
        /// The Object Lock mode that you want to apply to this object.
        public let objectLockMode: ObjectLockMode?
        /// The date and time when you want this object's Object Lock to expire.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var objectLockRetainUntilDate: Date?
        public let requestPayer: RequestPayer?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// Specifies the algorithm to use to when encrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This value is used to store the object and then it is discarded; Amazon S3 does not store the encryption key. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// Specifies the AWS KMS Encryption Context to use for object encryption. The value of this header is a base64-encoded UTF-8 string holding JSON with the encryption context key-value pairs.
        public let sSEKMSEncryptionContext: String?
        /// If x-amz-server-side-encryption is present and has the value of aws:kms, this header specifies the ID of the AWS Key Management Service (AWS KMS) symmetrical customer managed customer master key (CMK) that was used for the object.  If the value of x-amz-server-side-encryption is aws:kms, this header specifies the ID of the symmetric customer managed AWS KMS CMK that will be used for the object. If you specify x-amz-server-side-encryption:aws:kms, but do not provide x-amz-server-side-encryption-aws-kms-key-id, Amazon S3 uses the AWS managed CMK in AWS to protect the data.
        public let sSEKMSKeyId: String?
        /// By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. Amazon S3 on Outposts only uses the OUTPOSTS Storage Class. For more information, see Storage Classes in the Amazon S3 Service Developer Guide.
        public let storageClass: StorageClass?
        /// The tag-set for the object. The tag-set must be encoded as URL Query parameters. (For example, "Key1=Value1")
        public let tagging: String?
        /// If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata. For information about object metadata, see Object Key and Metadata. In the following example, the request header sets the redirect to an object (anotherPage.html) in the same bucket:  x-amz-website-redirect-location: /anotherPage.html  In the following example, the request header sets the object redirect to another website:  x-amz-website-redirect-location: http://www.example.com/  For more information about website hosting in Amazon S3, see Hosting Websites on Amazon S3 and How to Configure Website Page Redirects.
        public let websiteRedirectLocation: String?

        public init(acl: ObjectCannedACL? = nil, body: AWSPayload? = nil, bucket: String, bucketKeyEnabled: Bool? = nil, cacheControl: String? = nil, contentDisposition: String? = nil, contentEncoding: String? = nil, contentLanguage: String? = nil, contentLength: Int64? = nil, contentMD5: String? = nil, contentType: String? = nil, expectedBucketOwner: String? = nil, expires: Date? = nil, grantFullControl: String? = nil, grantRead: String? = nil, grantReadACP: String? = nil, grantWriteACP: String? = nil, key: String, metadata: [String: String]? = nil, objectLockLegalHoldStatus: ObjectLockLegalHoldStatus? = nil, objectLockMode: ObjectLockMode? = nil, objectLockRetainUntilDate: Date? = nil, requestPayer: RequestPayer? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSEncryptionContext: String? = nil, sSEKMSKeyId: String? = nil, storageClass: StorageClass? = nil, tagging: String? = nil, websiteRedirectLocation: String? = nil) {
            self.acl = acl
            self.body = body
            self.bucket = bucket
            self.bucketKeyEnabled = bucketKeyEnabled
            self.cacheControl = cacheControl
            self.contentDisposition = contentDisposition
            self.contentEncoding = contentEncoding
            self.contentLanguage = contentLanguage
            self.contentLength = contentLength
            self.contentMD5 = contentMD5
            self.contentType = contentType
            self.expectedBucketOwner = expectedBucketOwner
            self.expires = expires
            self.grantFullControl = grantFullControl
            self.grantRead = grantRead
            self.grantReadACP = grantReadACP
            self.grantWriteACP = grantWriteACP
            self.key = key
            self.metadata = metadata
            self.objectLockLegalHoldStatus = objectLockLegalHoldStatus
            self.objectLockMode = objectLockMode
            self.objectLockRetainUntilDate = objectLockRetainUntilDate
            self.requestPayer = requestPayer
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSEncryptionContext = sSEKMSEncryptionContext
            self.sSEKMSKeyId = sSEKMSKeyId
            self.storageClass = storageClass
            self.tagging = tagging
            self.websiteRedirectLocation = websiteRedirectLocation
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct PutObjectRetentionOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged"))
        ]

        public let requestCharged: RequestCharged?

        public init(requestCharged: RequestCharged? = nil) {
            self.requestCharged = requestCharged
        }

        private enum CodingKeys: String, CodingKey {
            case requestCharged = "x-amz-request-charged"
        }
    }

    public struct PutObjectRetentionRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "retention"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "bypassGovernanceRetention", location: .header(locationName: "x-amz-bypass-governance-retention")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "retention", location: .body(locationName: "Retention")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name that contains the object you want to apply this Object Retention configuration to.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Indicates whether this operation should bypass Governance-mode restrictions.
        public let bypassGovernanceRetention: Bool?
        /// The MD5 hash for the request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The key name for the object that you want to apply this Object Retention configuration to.
        public let key: String
        public let requestPayer: RequestPayer?
        /// The container element for the Object Retention configuration.
        public let retention: ObjectLockRetention?
        /// The version ID for the object that you want to apply this Object Retention configuration to.
        public let versionId: String?

        public init(bucket: String, bypassGovernanceRetention: Bool? = nil, contentMD5: String? = nil, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, retention: ObjectLockRetention? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.bypassGovernanceRetention = bypassGovernanceRetention
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.retention = retention
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case retention = "Retention"
        }
    }

    public struct PutObjectTaggingOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "versionId", location: .header(locationName: "x-amz-version-id"))
        ]

        /// The versionId of the object the tag-set was added to.
        public let versionId: String?

        public init(versionId: String? = nil) {
            self.versionId = versionId
        }

        private enum CodingKeys: String, CodingKey {
            case versionId = "x-amz-version-id"
        }
    }

    public struct PutObjectTaggingRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "tagging"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "tagging", location: .body(locationName: "Tagging")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The MD5 hash for the request body. For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Name of the object key.
        public let key: String
        public let requestPayer: RequestPayer?
        /// Container for the TagSet and Tag elements
        public let tagging: Tagging
        /// The versionId of the object that the tag-set will be added to.
        public let versionId: String?

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, tagging: Tagging, versionId: String? = nil) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.tagging = tagging
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
            try self.tagging.validate(name: "\(name).tagging")
        }

        private enum CodingKeys: String, CodingKey {
            case tagging = "Tagging"
        }
    }

    public struct PutPublicAccessBlockRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "publicAccessBlockConfiguration"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "publicAccessBlockConfiguration", location: .body(locationName: "PublicAccessBlockConfiguration"))
        ]

        /// The name of the Amazon S3 bucket whose PublicAccessBlock configuration you want to set.
        public let bucket: String
        /// The MD5 hash of the PutPublicAccessBlock request body.  For requests made using the AWS Command Line Interface (CLI) or AWS SDKs, this field is calculated automatically.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The PublicAccessBlock configuration that you want to apply to this Amazon S3 bucket. You can enable the configuration options in any combination. For more information about when Amazon S3 considers a bucket or object public, see The Meaning of "Public" in the Amazon Simple Storage Service Developer Guide.
        public let publicAccessBlockConfiguration: PublicAccessBlockConfiguration

        public init(bucket: String, contentMD5: String? = nil, expectedBucketOwner: String? = nil, publicAccessBlockConfiguration: PublicAccessBlockConfiguration) {
            self.bucket = bucket
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.publicAccessBlockConfiguration = publicAccessBlockConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case publicAccessBlockConfiguration = "PublicAccessBlockConfiguration"
        }
    }

    public struct QueueConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// A collection of bucket events for which to send notifications
        public let events: [Event]
        public let filter: NotificationConfigurationFilter?
        public let id: String?
        /// The Amazon Resource Name (ARN) of the Amazon SQS queue to which Amazon S3 publishes a message when it detects events of the specified type.
        public let queueArn: String

        public init(events: [Event], filter: NotificationConfigurationFilter? = nil, id: String? = nil, queueArn: String) {
            self.events = events
            self.filter = filter
            self.id = id
            self.queueArn = queueArn
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Event"
            case filter = "Filter"
            case id = "Id"
            case queueArn = "Queue"
        }
    }

    public struct QueueConfigurationDeprecated: AWSEncodableShape & AWSDecodableShape {
        /// A collection of bucket events for which to send notifications
        public let events: [Event]?
        public let id: String?
        /// The Amazon Resource Name (ARN) of the Amazon SQS queue to which Amazon S3 publishes a message when it detects events of the specified type.
        public let queue: String?

        public init(events: [Event]? = nil, id: String? = nil, queue: String? = nil) {
            self.events = events
            self.id = id
            self.queue = queue
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Event"
            case id = "Id"
            case queue = "Queue"
        }
    }

    public struct RecordsEvent: AWSDecodableShape {
        /// The byte array of partial, one or more result records.
        public let payload: Data?

        public init(payload: Data? = nil) {
            self.payload = payload
        }

        private enum CodingKeys: String, CodingKey {
            case payload = "Payload"
        }
    }

    public struct Redirect: AWSEncodableShape & AWSDecodableShape {
        /// The host name to use in the redirect request.
        public let hostName: String?
        /// The HTTP redirect code to use on the response. Not required if one of the siblings is present.
        public let httpRedirectCode: String?
        /// Protocol to use when redirecting requests. The default is the protocol that is used in the original request.
        public let `protocol`: Protocol?
        /// The object key prefix to use in the redirect request. For example, to redirect requests for all pages with prefix docs/ (objects in the docs/ folder) to documents/, you can set a condition block with KeyPrefixEquals set to docs/ and in the Redirect set ReplaceKeyPrefixWith to /documents. Not required if one of the siblings is present. Can be present only if ReplaceKeyWith is not provided.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let replaceKeyPrefixWith: String?
        /// The specific object key to use in the redirect request. For example, redirect request to error.html. Not required if one of the siblings is present. Can be present only if ReplaceKeyPrefixWith is not provided.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let replaceKeyWith: String?

        public init(hostName: String? = nil, httpRedirectCode: String? = nil, protocol: Protocol? = nil, replaceKeyPrefixWith: String? = nil, replaceKeyWith: String? = nil) {
            self.hostName = hostName
            self.httpRedirectCode = httpRedirectCode
            self.`protocol` = `protocol`
            self.replaceKeyPrefixWith = replaceKeyPrefixWith
            self.replaceKeyWith = replaceKeyWith
        }

        private enum CodingKeys: String, CodingKey {
            case hostName = "HostName"
            case httpRedirectCode = "HttpRedirectCode"
            case `protocol` = "Protocol"
            case replaceKeyPrefixWith = "ReplaceKeyPrefixWith"
            case replaceKeyWith = "ReplaceKeyWith"
        }
    }

    public struct RedirectAllRequestsTo: AWSEncodableShape & AWSDecodableShape {
        /// Name of the host where requests are redirected.
        public let hostName: String
        /// Protocol to use when redirecting requests. The default is the protocol that is used in the original request.
        public let `protocol`: Protocol?

        public init(hostName: String, protocol: Protocol? = nil) {
            self.hostName = hostName
            self.`protocol` = `protocol`
        }

        private enum CodingKeys: String, CodingKey {
            case hostName = "HostName"
            case `protocol` = "Protocol"
        }
    }

    public struct ReplicaModifications: AWSEncodableShape & AWSDecodableShape {
        /// Specifies whether Amazon S3 replicates modifications on replicas.
        public let status: ReplicaModificationsStatus

        public init(status: ReplicaModificationsStatus) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct ReplicationConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that Amazon S3 assumes when replicating objects. For more information, see How to Set Up Replication in the Amazon Simple Storage Service Developer Guide.
        public let role: String
        /// A container for one or more replication rules. A replication configuration must have at least one rule and can contain a maximum of 1,000 rules.
        public let rules: [ReplicationRule]

        public init(role: String, rules: [ReplicationRule]) {
            self.role = role
            self.rules = rules
        }

        public func validate(name: String) throws {
            try self.rules.forEach {
                try $0.validate(name: "\(name).rules[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case role = "Role"
            case rules = "Rule"
        }
    }

    public struct ReplicationRule: AWSEncodableShape & AWSDecodableShape {
        public let deleteMarkerReplication: DeleteMarkerReplication?
        /// A container for information about the replication destination and its configurations including enabling the S3 Replication Time Control (S3 RTC).
        public let destination: Destination
        public let existingObjectReplication: ExistingObjectReplication?
        public let filter: ReplicationRuleFilter?
        /// A unique identifier for the rule. The maximum value is 255 characters.
        public let id: String?
        /// The priority indicates which rule has precedence whenever two or more replication rules conflict. Amazon S3 will attempt to replicate objects according to all replication rules. However, if there are two or more rules with the same destination bucket, then objects will be replicated according to the rule with the highest priority. The higher the number, the higher the priority.  For more information, see Replication in the Amazon Simple Storage Service Developer Guide.
        public let priority: Int?
        /// A container that describes additional filters for identifying the source objects that you want to replicate. You can choose to enable or disable the replication of these objects. Currently, Amazon S3 supports only the filter that you can specify for objects created with server-side encryption using a customer master key (CMK) stored in AWS Key Management Service (SSE-KMS).
        public let sourceSelectionCriteria: SourceSelectionCriteria?
        /// Specifies whether the rule is enabled.
        public let status: ReplicationRuleStatus

        public init(deleteMarkerReplication: DeleteMarkerReplication? = nil, destination: Destination, existingObjectReplication: ExistingObjectReplication? = nil, filter: ReplicationRuleFilter? = nil, id: String? = nil, priority: Int? = nil, sourceSelectionCriteria: SourceSelectionCriteria? = nil, status: ReplicationRuleStatus) {
            self.deleteMarkerReplication = deleteMarkerReplication
            self.destination = destination
            self.existingObjectReplication = existingObjectReplication
            self.filter = filter
            self.id = id
            self.priority = priority
            self.sourceSelectionCriteria = sourceSelectionCriteria
            self.status = status
        }

        public func validate(name: String) throws {
            try self.filter?.validate(name: "\(name).filter")
        }

        private enum CodingKeys: String, CodingKey {
            case deleteMarkerReplication = "DeleteMarkerReplication"
            case destination = "Destination"
            case existingObjectReplication = "ExistingObjectReplication"
            case filter = "Filter"
            case id = "ID"
            case priority = "Priority"
            case sourceSelectionCriteria = "SourceSelectionCriteria"
            case status = "Status"
        }
    }

    public struct ReplicationRuleAndOperator: AWSEncodableShape & AWSDecodableShape {
        /// An object key name prefix that identifies the subset of objects to which the rule applies.
        public let prefix: String?
        /// An array of tags containing key and value pairs.
        public let tags: [Tag]?

        public init(prefix: String? = nil, tags: [Tag]? = nil) {
            self.prefix = prefix
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case prefix = "Prefix"
            case tags = "Tag"
        }
    }

    public struct ReplicationRuleFilter: AWSEncodableShape & AWSDecodableShape {
        /// A container for specifying rule filters. The filters determine the subset of objects to which the rule applies. This element is required only if you specify more than one filter. For example:    If you specify both a Prefix and a Tag filter, wrap these filters in an And tag.   If you specify a filter based on multiple tags, wrap the Tag elements in an And tag.
        public let and: ReplicationRuleAndOperator?
        /// An object key name prefix that identifies the subset of objects to which the rule applies.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let prefix: String?
        /// A container for specifying a tag key and value.  The rule applies only to objects that have the tag in their tag set.
        public let tag: Tag?

        public init(and: ReplicationRuleAndOperator? = nil, prefix: String? = nil, tag: Tag? = nil) {
            self.and = and
            self.prefix = prefix
            self.tag = tag
        }

        public func validate(name: String) throws {
            try self.and?.validate(name: "\(name).and")
            try self.tag?.validate(name: "\(name).tag")
        }

        private enum CodingKeys: String, CodingKey {
            case and = "And"
            case prefix = "Prefix"
            case tag = "Tag"
        }
    }

    public struct ReplicationTime: AWSEncodableShape & AWSDecodableShape {
        ///  Specifies whether the replication time is enabled.
        public let status: ReplicationTimeStatus
        ///  A container specifying the time by which replication should be complete for all objects and operations on objects.
        public let time: ReplicationTimeValue

        public init(status: ReplicationTimeStatus, time: ReplicationTimeValue) {
            self.status = status
            self.time = time
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
            case time = "Time"
        }
    }

    public struct ReplicationTimeValue: AWSEncodableShape & AWSDecodableShape {
        ///  Contains an integer specifying time in minutes.   Valid values: 15 minutes.
        public let minutes: Int?

        public init(minutes: Int? = nil) {
            self.minutes = minutes
        }

        private enum CodingKeys: String, CodingKey {
            case minutes = "Minutes"
        }
    }

    public struct RequestPaymentConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies who pays for the download and request fees.
        public let payer: Payer

        public init(payer: Payer) {
            self.payer = payer
        }

        private enum CodingKeys: String, CodingKey {
            case payer = "Payer"
        }
    }

    public struct RequestProgress: AWSEncodableShape {
        /// Specifies whether periodic QueryProgress frames should be sent. Valid values: TRUE, FALSE. Default value: FALSE.
        public let enabled: Bool?

        public init(enabled: Bool? = nil) {
            self.enabled = enabled
        }

        private enum CodingKeys: String, CodingKey {
            case enabled = "Enabled"
        }
    }

    public struct RestoreObjectOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "restoreOutputPath", location: .header(locationName: "x-amz-restore-output-path"))
        ]

        public let requestCharged: RequestCharged?
        /// Indicates the path in the provided S3 output location where Select results will be restored to.
        public let restoreOutputPath: String?

        public init(requestCharged: RequestCharged? = nil, restoreOutputPath: String? = nil) {
            self.requestCharged = requestCharged
            self.restoreOutputPath = restoreOutputPath
        }

        private enum CodingKeys: String, CodingKey {
            case requestCharged = "x-amz-request-charged"
            case restoreOutputPath = "x-amz-restore-output-path"
        }
    }

    public struct RestoreObjectRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "restoreRequest"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "restoreRequest", location: .body(locationName: "RestoreRequest")),
            AWSMemberEncoding(label: "versionId", location: .querystring(locationName: "versionId"))
        ]

        /// The bucket name containing the object to restore.  When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Object key for which the operation was initiated.
        public let key: String
        public let requestPayer: RequestPayer?
        public let restoreRequest: RestoreRequest?
        /// VersionId used to reference a specific version of the object.
        public let versionId: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, key: String, requestPayer: RequestPayer? = nil, restoreRequest: RestoreRequest? = nil, versionId: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.requestPayer = requestPayer
            self.restoreRequest = restoreRequest
            self.versionId = versionId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
            try self.restoreRequest?.validate(name: "\(name).restoreRequest")
        }

        private enum CodingKeys: String, CodingKey {
            case restoreRequest = "RestoreRequest"
        }
    }

    public struct RestoreRequest: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Lifetime of the active copy in days. Do not use with restores that specify OutputLocation. The Days element is required for regular restores, and must not be provided for select requests.
        public let days: Int?
        /// The optional description for the job.
        public let description: String?
        /// S3 Glacier related parameters pertaining to this job. Do not use with restores that specify OutputLocation.
        public let glacierJobParameters: GlacierJobParameters?
        /// Describes the location where the restore job's output is stored.
        public let outputLocation: OutputLocation?
        /// Describes the parameters for Select job types.
        public let selectParameters: SelectParameters?
        /// Retrieval tier at which the restore will be processed.
        public let tier: Tier?
        /// Type of restore request.
        public let type: RestoreRequestType?

        public init(days: Int? = nil, description: String? = nil, glacierJobParameters: GlacierJobParameters? = nil, outputLocation: OutputLocation? = nil, selectParameters: SelectParameters? = nil, tier: Tier? = nil, type: RestoreRequestType? = nil) {
            self.days = days
            self.description = description
            self.glacierJobParameters = glacierJobParameters
            self.outputLocation = outputLocation
            self.selectParameters = selectParameters
            self.tier = tier
            self.type = type
        }

        public func validate(name: String) throws {
            try self.outputLocation?.validate(name: "\(name).outputLocation")
        }

        private enum CodingKeys: String, CodingKey {
            case days = "Days"
            case description = "Description"
            case glacierJobParameters = "GlacierJobParameters"
            case outputLocation = "OutputLocation"
            case selectParameters = "SelectParameters"
            case tier = "Tier"
            case type = "Type"
        }
    }

    public struct RoutingRule: AWSEncodableShape & AWSDecodableShape {
        /// A container for describing a condition that must be met for the specified redirect to apply. For example, 1. If request is for pages in the /docs folder, redirect to the /documents folder. 2. If request results in HTTP error 4xx, redirect request to another host where you might process the error.
        public let condition: Condition?
        /// Container for redirect information. You can redirect requests to another host, to another page, or with another protocol. In the event of an error, you can specify a different error code to return.
        public let redirect: Redirect

        public init(condition: Condition? = nil, redirect: Redirect) {
            self.condition = condition
            self.redirect = redirect
        }

        private enum CodingKeys: String, CodingKey {
            case condition = "Condition"
            case redirect = "Redirect"
        }
    }

    public struct Rule: AWSEncodableShape & AWSDecodableShape {
        public let abortIncompleteMultipartUpload: AbortIncompleteMultipartUpload?
        /// Specifies the expiration for the lifecycle of the object.
        public let expiration: LifecycleExpiration?
        /// Unique identifier for the rule. The value can't be longer than 255 characters.
        public let id: String?
        public let noncurrentVersionExpiration: NoncurrentVersionExpiration?
        public let noncurrentVersionTransition: NoncurrentVersionTransition?
        /// Object key prefix that identifies one or more objects to which this rule applies.  Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see  XML related object key constraints.
        public let prefix: String
        /// If Enabled, the rule is currently being applied. If Disabled, the rule is not currently being applied.
        public let status: ExpirationStatus
        /// Specifies when an object transitions to a specified storage class. For more information about Amazon S3 lifecycle configuration rules, see Transitioning Objects Using Amazon S3 Lifecycle in the Amazon Simple Storage Service Developer Guide.
        public let transition: Transition?

        public init(abortIncompleteMultipartUpload: AbortIncompleteMultipartUpload? = nil, expiration: LifecycleExpiration? = nil, id: String? = nil, noncurrentVersionExpiration: NoncurrentVersionExpiration? = nil, noncurrentVersionTransition: NoncurrentVersionTransition? = nil, prefix: String, status: ExpirationStatus, transition: Transition? = nil) {
            self.abortIncompleteMultipartUpload = abortIncompleteMultipartUpload
            self.expiration = expiration
            self.id = id
            self.noncurrentVersionExpiration = noncurrentVersionExpiration
            self.noncurrentVersionTransition = noncurrentVersionTransition
            self.prefix = prefix
            self.status = status
            self.transition = transition
        }

        private enum CodingKeys: String, CodingKey {
            case abortIncompleteMultipartUpload = "AbortIncompleteMultipartUpload"
            case expiration = "Expiration"
            case id = "ID"
            case noncurrentVersionExpiration = "NoncurrentVersionExpiration"
            case noncurrentVersionTransition = "NoncurrentVersionTransition"
            case prefix = "Prefix"
            case status = "Status"
            case transition = "Transition"
        }
    }

    public struct S3KeyFilter: AWSEncodableShape & AWSDecodableShape {
        public let filterRules: [FilterRule]?

        public init(filterRules: [FilterRule]? = nil) {
            self.filterRules = filterRules
        }

        private enum CodingKeys: String, CodingKey {
            case filterRules = "FilterRule"
        }
    }

    public struct S3Location: AWSEncodableShape {
        public struct _AccessControlListEncoding: ArrayCoderProperties { public static let member = "Grant" }
        public struct _UserMetadataEncoding: ArrayCoderProperties { public static let member = "MetadataEntry" }

        /// A list of grants that control access to the staged results.
        @OptionalCustomCoding<ArrayCoder<_AccessControlListEncoding, Grant>>
        public var accessControlList: [Grant]?
        /// The name of the bucket where the restore results will be placed.
        public let bucketName: String
        /// The canned ACL to apply to the restore results.
        public let cannedACL: ObjectCannedACL?
        public let encryption: Encryption?
        /// The prefix that is prepended to the restore results for this request.
        public let prefix: String
        /// The class of storage used to store the restore results.
        public let storageClass: StorageClass?
        /// The tag-set that is applied to the restore results.
        public let tagging: Tagging?
        /// A list of metadata to store with the restore results in S3.
        @OptionalCustomCoding<ArrayCoder<_UserMetadataEncoding, MetadataEntry>>
        public var userMetadata: [MetadataEntry]?

        public init(accessControlList: [Grant]? = nil, bucketName: String, cannedACL: ObjectCannedACL? = nil, encryption: Encryption? = nil, prefix: String, storageClass: StorageClass? = nil, tagging: Tagging? = nil, userMetadata: [MetadataEntry]? = nil) {
            self.accessControlList = accessControlList
            self.bucketName = bucketName
            self.cannedACL = cannedACL
            self.encryption = encryption
            self.prefix = prefix
            self.storageClass = storageClass
            self.tagging = tagging
            self.userMetadata = userMetadata
        }

        public func validate(name: String) throws {
            try self.tagging?.validate(name: "\(name).tagging")
        }

        private enum CodingKeys: String, CodingKey {
            case accessControlList = "AccessControlList"
            case bucketName = "BucketName"
            case cannedACL = "CannedACL"
            case encryption = "Encryption"
            case prefix = "Prefix"
            case storageClass = "StorageClass"
            case tagging = "Tagging"
            case userMetadata = "UserMetadata"
        }
    }

    public struct SSEKMS: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) to use for encrypting inventory reports.
        public let keyId: String

        public init(keyId: String) {
            self.keyId = keyId
        }

        private enum CodingKeys: String, CodingKey {
            case keyId = "KeyId"
        }
    }

    public struct SSES3: AWSEncodableShape & AWSDecodableShape {
        public init() {}
    }

    public struct ScanRange: AWSEncodableShape {
        /// Specifies the end of the byte range. This parameter is optional. Valid values: non-negative integers. The default value is one less than the size of the object being queried. If only the End parameter is supplied, it is interpreted to mean scan the last N bytes of the file. For example, &lt;scanrange&gt;&lt;end&gt;50&lt;/end&gt;&lt;/scanrange&gt; means scan the last 50 bytes.
        public let end: Int64?
        /// Specifies the start of the byte range. This parameter is optional. Valid values: non-negative integers. The default value is 0. If only start is supplied, it means scan from that point to the end of the file.For example; &lt;scanrange&gt;&lt;start&gt;50&lt;/start&gt;&lt;/scanrange&gt; means scan from byte 50 until the end of the file.
        public let start: Int64?

        public init(end: Int64? = nil, start: Int64? = nil) {
            self.end = end
            self.start = start
        }

        private enum CodingKeys: String, CodingKey {
            case end = "End"
            case start = "Start"
        }
    }

    public struct SelectObjectContentEventStream: AWSDecodableShape {
        /// The Continuation Event.
        public let cont: ContinuationEvent?
        /// The End Event.
        public let end: EndEvent?
        /// The Progress Event.
        public let progress: ProgressEvent?
        /// The Records Event.
        public let records: RecordsEvent?
        /// The Stats Event.
        public let stats: StatsEvent?

        public init(cont: ContinuationEvent? = nil, end: EndEvent? = nil, progress: ProgressEvent? = nil, records: RecordsEvent? = nil, stats: StatsEvent? = nil) {
            self.cont = cont
            self.end = end
            self.progress = progress
            self.records = records
            self.stats = stats
        }

        private enum CodingKeys: String, CodingKey {
            case cont = "Cont"
            case end = "End"
            case progress = "Progress"
            case records = "Records"
            case stats = "Stats"
        }
    }

    public struct SelectObjectContentOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "payload"
        public static var _encoding = [
            AWSMemberEncoding(label: "payload", location: .body(locationName: "Payload"))
        ]

        /// The array of results.
        public let payload: SelectObjectContentEventStream?

        public init(payload: SelectObjectContentEventStream? = nil) {
            self.payload = payload
        }

        private enum CodingKeys: String, CodingKey {
            case payload = "Payload"
        }
    }

    public struct SelectObjectContentRequest: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5"))
        ]

        /// The S3 bucket.
        public let bucket: String
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The expression that is used to query the object.
        public let expression: String
        /// The type of the provided expression (for example, SQL).
        public let expressionType: ExpressionType
        /// Describes the format of the data in the object that is being queried.
        public let inputSerialization: InputSerialization
        /// The object key.
        public let key: String
        /// Describes the format of the data that you want Amazon S3 to return in response.
        public let outputSerialization: OutputSerialization
        /// Specifies if periodic request progress information should be enabled.
        public let requestProgress: RequestProgress?
        /// Specifies the byte range of the object to get the records from. A record is processed when its first byte is contained by the range. This parameter is optional, but when specified, it must not be empty. See RFC 2616, Section 14.35.1 about how to specify the start and end of the range.  ScanRangemay be used in the following ways:    &lt;scanrange&gt;&lt;start&gt;50&lt;/start&gt;&lt;end&gt;100&lt;/end&gt;&lt;/scanrange&gt; - process only the records starting between the bytes 50 and 100 (inclusive, counting from zero)    &lt;scanrange&gt;&lt;start&gt;50&lt;/start&gt;&lt;/scanrange&gt; - process only the records starting after the byte 50    &lt;scanrange&gt;&lt;end&gt;50&lt;/end&gt;&lt;/scanrange&gt; - process only the records within the last 50 bytes of the file.
        public let scanRange: ScanRange?
        /// The SSE Algorithm used to encrypt the object. For more information, see Server-Side Encryption (Using Customer-Provided Encryption Keys.
        public let sSECustomerAlgorithm: String?
        /// The SSE Customer Key. For more information, see Server-Side Encryption (Using Customer-Provided Encryption Keys.
        public let sSECustomerKey: String?
        /// The SSE Customer Key MD5. For more information, see Server-Side Encryption (Using Customer-Provided Encryption Keys.
        public let sSECustomerKeyMD5: String?

        public init(bucket: String, expectedBucketOwner: String? = nil, expression: String, expressionType: ExpressionType, inputSerialization: InputSerialization, key: String, outputSerialization: OutputSerialization, requestProgress: RequestProgress? = nil, scanRange: ScanRange? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil) {
            self.bucket = bucket
            self.expectedBucketOwner = expectedBucketOwner
            self.expression = expression
            self.expressionType = expressionType
            self.inputSerialization = inputSerialization
            self.key = key
            self.outputSerialization = outputSerialization
            self.requestProgress = requestProgress
            self.scanRange = scanRange
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case expression = "Expression"
            case expressionType = "ExpressionType"
            case inputSerialization = "InputSerialization"
            case outputSerialization = "OutputSerialization"
            case requestProgress = "RequestProgress"
            case scanRange = "ScanRange"
        }
    }

    public struct SelectParameters: AWSEncodableShape {
        /// The expression that is used to query the object.
        public let expression: String
        /// The type of the provided expression (for example, SQL).
        public let expressionType: ExpressionType
        /// Describes the serialization format of the object.
        public let inputSerialization: InputSerialization
        /// Describes how the results of the Select job are serialized.
        public let outputSerialization: OutputSerialization

        public init(expression: String, expressionType: ExpressionType, inputSerialization: InputSerialization, outputSerialization: OutputSerialization) {
            self.expression = expression
            self.expressionType = expressionType
            self.inputSerialization = inputSerialization
            self.outputSerialization = outputSerialization
        }

        private enum CodingKeys: String, CodingKey {
            case expression = "Expression"
            case expressionType = "ExpressionType"
            case inputSerialization = "InputSerialization"
            case outputSerialization = "OutputSerialization"
        }
    }

    public struct ServerSideEncryptionByDefault: AWSEncodableShape & AWSDecodableShape {
        /// AWS Key Management Service (KMS) customer master key ID to use for the default encryption. This parameter is allowed if and only if SSEAlgorithm is set to aws:kms. You can specify the key ID or the Amazon Resource Name (ARN) of the CMK. However, if you are using encryption with cross-account operations, you must use a fully qualified CMK ARN. For more information, see Using encryption for cross-account operations.   For example:    Key ID: 1234abcd-12ab-34cd-56ef-1234567890ab    Key ARN: arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab     Amazon S3 only supports symmetric CMKs and not asymmetric CMKs. For more information, see Using Symmetric and Asymmetric Keys in the AWS Key Management Service Developer Guide.
        public let kMSMasterKeyID: String?
        /// Server-side encryption algorithm to use for the default encryption.
        public let sSEAlgorithm: ServerSideEncryption

        public init(kMSMasterKeyID: String? = nil, sSEAlgorithm: ServerSideEncryption) {
            self.kMSMasterKeyID = kMSMasterKeyID
            self.sSEAlgorithm = sSEAlgorithm
        }

        private enum CodingKeys: String, CodingKey {
            case kMSMasterKeyID = "KMSMasterKeyID"
            case sSEAlgorithm = "SSEAlgorithm"
        }
    }

    public struct ServerSideEncryptionConfiguration: AWSEncodableShape & AWSDecodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Container for information about a particular server-side encryption configuration rule.
        public let rules: [ServerSideEncryptionRule]

        public init(rules: [ServerSideEncryptionRule]) {
            self.rules = rules
        }

        private enum CodingKeys: String, CodingKey {
            case rules = "Rule"
        }
    }

    public struct ServerSideEncryptionRule: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.
        public let applyServerSideEncryptionByDefault: ServerSideEncryptionByDefault?
        /// Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the BucketKeyEnabled element to true causes Amazon S3 to use an S3 Bucket Key. By default, S3 Bucket Key is not enabled. For more information, see Amazon S3 Bucket Keys in the Amazon Simple Storage Service Developer Guide.
        public let bucketKeyEnabled: Bool?

        public init(applyServerSideEncryptionByDefault: ServerSideEncryptionByDefault? = nil, bucketKeyEnabled: Bool? = nil) {
            self.applyServerSideEncryptionByDefault = applyServerSideEncryptionByDefault
            self.bucketKeyEnabled = bucketKeyEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case applyServerSideEncryptionByDefault = "ApplyServerSideEncryptionByDefault"
            case bucketKeyEnabled = "BucketKeyEnabled"
        }
    }

    public struct SourceSelectionCriteria: AWSEncodableShape & AWSDecodableShape {
        /// A filter that you can specify for selections for modifications on replicas. Amazon S3 doesn't replicate replica modifications by default. In the latest version of replication configuration (when Filter is specified), you can specify this element and set the status to Enabled to replicate modifications on replicas.    If you don't specify the Filter element, Amazon S3 assumes that the replication configuration is the earlier version, V1. In the earlier version, this element is not allowed
        public let replicaModifications: ReplicaModifications?
        ///  A container for filter information for the selection of Amazon S3 objects encrypted with AWS KMS. If you include SourceSelectionCriteria in the replication configuration, this element is required.
        public let sseKmsEncryptedObjects: SseKmsEncryptedObjects?

        public init(replicaModifications: ReplicaModifications? = nil, sseKmsEncryptedObjects: SseKmsEncryptedObjects? = nil) {
            self.replicaModifications = replicaModifications
            self.sseKmsEncryptedObjects = sseKmsEncryptedObjects
        }

        private enum CodingKeys: String, CodingKey {
            case replicaModifications = "ReplicaModifications"
            case sseKmsEncryptedObjects = "SseKmsEncryptedObjects"
        }
    }

    public struct SseKmsEncryptedObjects: AWSEncodableShape & AWSDecodableShape {
        /// Specifies whether Amazon S3 replicates objects created with server-side encryption using a customer master key (CMK) stored in AWS Key Management Service.
        public let status: SseKmsEncryptedObjectsStatus

        public init(status: SseKmsEncryptedObjectsStatus) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct Stats: AWSDecodableShape {
        /// The total number of uncompressed object bytes processed.
        public let bytesProcessed: Int64?
        /// The total number of bytes of records payload data returned.
        public let bytesReturned: Int64?
        /// The total number of object bytes scanned.
        public let bytesScanned: Int64?

        public init(bytesProcessed: Int64? = nil, bytesReturned: Int64? = nil, bytesScanned: Int64? = nil) {
            self.bytesProcessed = bytesProcessed
            self.bytesReturned = bytesReturned
            self.bytesScanned = bytesScanned
        }

        private enum CodingKeys: String, CodingKey {
            case bytesProcessed = "BytesProcessed"
            case bytesReturned = "BytesReturned"
            case bytesScanned = "BytesScanned"
        }
    }

    public struct StatsEvent: AWSDecodableShape {
        /// The Stats event details.
        public let details: Stats?

        public init(details: Stats? = nil) {
            self.details = details
        }

        private enum CodingKeys: String, CodingKey {
            case details = "Details"
        }
    }

    public struct StorageClassAnalysis: AWSEncodableShape & AWSDecodableShape {
        /// Specifies how data related to the storage class analysis for an Amazon S3 bucket should be exported.
        public let dataExport: StorageClassAnalysisDataExport?

        public init(dataExport: StorageClassAnalysisDataExport? = nil) {
            self.dataExport = dataExport
        }

        private enum CodingKeys: String, CodingKey {
            case dataExport = "DataExport"
        }
    }

    public struct StorageClassAnalysisDataExport: AWSEncodableShape & AWSDecodableShape {
        /// The place to store the data for an analysis.
        public let destination: AnalyticsExportDestination
        /// The version of the output schema to use when exporting data. Must be V_1.
        public let outputSchemaVersion: StorageClassAnalysisSchemaVersion

        public init(destination: AnalyticsExportDestination, outputSchemaVersion: StorageClassAnalysisSchemaVersion) {
            self.destination = destination
            self.outputSchemaVersion = outputSchemaVersion
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
            case outputSchemaVersion = "OutputSchemaVersion"
        }
    }

    public struct Tag: AWSEncodableShape & AWSDecodableShape {
        /// Name of the object key.
        public let key: String
        /// Value of the tag.
        public let value: String

        public init(key: String, value: String) {
            self.key = key
            self.value = value
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
            case value = "Value"
        }
    }

    public struct Tagging: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"
        public struct _TagSetEncoding: ArrayCoderProperties { public static let member = "Tag" }

        /// A collection for a set of tags
        @CustomCoding<ArrayCoder<_TagSetEncoding, Tag>>
        public var tagSet: [Tag]

        public init(tagSet: [Tag]) {
            self.tagSet = tagSet
        }

        public func validate(name: String) throws {
            try self.tagSet.forEach {
                try $0.validate(name: "\(name).tagSet[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case tagSet = "TagSet"
        }
    }

    public struct TargetGrant: AWSEncodableShape & AWSDecodableShape {
        /// Container for the person being granted permissions.
        public let grantee: Grantee?
        /// Logging permissions assigned to the grantee for the bucket.
        public let permission: BucketLogsPermission?

        public init(grantee: Grantee? = nil, permission: BucketLogsPermission? = nil) {
            self.grantee = grantee
            self.permission = permission
        }

        private enum CodingKeys: String, CodingKey {
            case grantee = "Grantee"
            case permission = "Permission"
        }
    }

    public struct Tiering: AWSEncodableShape & AWSDecodableShape {
        /// S3 Intelligent-Tiering access tier. See Storage class for automatically optimizing frequently and infrequently accessed objects for a list of access tiers in the S3 Intelligent-Tiering storage class.
        public let accessTier: IntelligentTieringAccessTier
        /// The number of consecutive days of no access after which an object will be eligible to be transitioned to the corresponding tier. The minimum number of days specified for Archive Access tier must be at least 90 days and Deep Archive Access tier must be at least 180 days. The maximum can be up to 2 years (730 days).
        public let days: Int

        public init(accessTier: IntelligentTieringAccessTier, days: Int) {
            self.accessTier = accessTier
            self.days = days
        }

        private enum CodingKeys: String, CodingKey {
            case accessTier = "AccessTier"
            case days = "Days"
        }
    }

    public struct TopicConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon S3 bucket event about which to send notifications. For more information, see Supported Event Types in the Amazon Simple Storage Service Developer Guide.
        public let events: [Event]
        public let filter: NotificationConfigurationFilter?
        public let id: String?
        /// The Amazon Resource Name (ARN) of the Amazon SNS topic to which Amazon S3 publishes a message when it detects events of the specified type.
        public let topicArn: String

        public init(events: [Event], filter: NotificationConfigurationFilter? = nil, id: String? = nil, topicArn: String) {
            self.events = events
            self.filter = filter
            self.id = id
            self.topicArn = topicArn
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Event"
            case filter = "Filter"
            case id = "Id"
            case topicArn = "Topic"
        }
    }

    public struct TopicConfigurationDeprecated: AWSEncodableShape & AWSDecodableShape {
        /// A collection of events related to objects
        public let events: [Event]?
        public let id: String?
        /// Amazon SNS topic to which Amazon S3 will publish a message to report the specified events for the bucket.
        public let topic: String?

        public init(events: [Event]? = nil, id: String? = nil, topic: String? = nil) {
            self.events = events
            self.id = id
            self.topic = topic
        }

        private enum CodingKeys: String, CodingKey {
            case events = "Event"
            case id = "Id"
            case topic = "Topic"
        }
    }

    public struct Transition: AWSEncodableShape & AWSDecodableShape {
        /// Indicates when objects are transitioned to the specified storage class. The date value must be in ISO 8601 format. The time is always midnight UTC.
        @OptionalCustomCoding<ISO8601DateCoder>
        public var date: Date?
        /// Indicates the number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer.
        public let days: Int?
        /// The storage class to which you want the object to transition.
        public let storageClass: TransitionStorageClass?

        public init(date: Date? = nil, days: Int? = nil, storageClass: TransitionStorageClass? = nil) {
            self.date = date
            self.days = days
            self.storageClass = storageClass
        }

        private enum CodingKeys: String, CodingKey {
            case date = "Date"
            case days = "Days"
            case storageClass = "StorageClass"
        }
    }

    public struct UploadPartCopyOutput: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "copyPartResult"
        public static var _encoding = [
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "copyPartResult", location: .body(locationName: "CopyPartResult")),
            AWSMemberEncoding(label: "copySourceVersionId", location: .header(locationName: "x-amz-copy-source-version-id")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id"))
        ]

        /// Indicates whether the multipart upload uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Container for all response elements.
        public let copyPartResult: CopyPartResult?
        /// The version of the source object that was copied, if you have enabled versioning on the source bucket.
        public let copySourceVersionId: String?
        public let requestCharged: RequestCharged?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) that was used for the object.
        public let sSEKMSKeyId: String?

        public init(bucketKeyEnabled: Bool? = nil, copyPartResult: CopyPartResult? = nil, copySourceVersionId: String? = nil, requestCharged: RequestCharged? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSKeyId: String? = nil) {
            self.bucketKeyEnabled = bucketKeyEnabled
            self.copyPartResult = copyPartResult
            self.copySourceVersionId = copySourceVersionId
            self.requestCharged = requestCharged
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSKeyId = sSEKMSKeyId
        }

        private enum CodingKeys: String, CodingKey {
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case copyPartResult = "CopyPartResult"
            case copySourceVersionId = "x-amz-copy-source-version-id"
            case requestCharged = "x-amz-request-charged"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
        }
    }

    public struct UploadPartCopyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "copySource", location: .header(locationName: "x-amz-copy-source")),
            AWSMemberEncoding(label: "copySourceIfMatch", location: .header(locationName: "x-amz-copy-source-if-match")),
            AWSMemberEncoding(label: "_copySourceIfModifiedSince", location: .header(locationName: "x-amz-copy-source-if-modified-since")),
            AWSMemberEncoding(label: "copySourceIfNoneMatch", location: .header(locationName: "x-amz-copy-source-if-none-match")),
            AWSMemberEncoding(label: "_copySourceIfUnmodifiedSince", location: .header(locationName: "x-amz-copy-source-if-unmodified-since")),
            AWSMemberEncoding(label: "copySourceRange", location: .header(locationName: "x-amz-copy-source-range")),
            AWSMemberEncoding(label: "copySourceSSECustomerAlgorithm", location: .header(locationName: "x-amz-copy-source-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "copySourceSSECustomerKey", location: .header(locationName: "x-amz-copy-source-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "copySourceSSECustomerKeyMD5", location: .header(locationName: "x-amz-copy-source-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "expectedSourceBucketOwner", location: .header(locationName: "x-amz-source-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "partNumber", location: .querystring(locationName: "partNumber")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "uploadId", location: .querystring(locationName: "uploadId"))
        ]

        /// The bucket name. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Specifies the source object for the copy operation. You specify the value in one of two formats, depending on whether you want to access the source object through an access point:   For objects not accessed through an access point, specify the name of the source bucket and key of the source object, separated by a slash (/). For example, to copy the object reports/january.pdf from the bucket awsexamplebucket, use awsexamplebucket/reports/january.pdf. The value must be URL encoded.   For objects accessed through access points, specify the Amazon Resource Name (ARN) of the object as accessed through the access point, in the format arn:aws:s3:&lt;Region&gt;:&lt;account-id&gt;:accesspoint/&lt;access-point-name&gt;/object/&lt;key&gt;. For example, to copy the object reports/january.pdf through access point my-access-point owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3:us-west-2:123456789012:accesspoint/my-access-point/object/reports/january.pdf. The value must be URL encoded.  Amazon S3 supports copy operations using access points only when the source and destination buckets are in the same AWS Region.  Alternatively, for objects accessed through Amazon S3 on Outposts, specify the ARN of the object as accessed in the format arn:aws:s3-outposts:&lt;Region&gt;:&lt;account-id&gt;:outpost/&lt;outpost-id&gt;/object/&lt;key&gt;. For example, to copy the object reports/january.pdf through outpost my-outpost owned by account 123456789012 in Region us-west-2, use the URL encoding of arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/object/reports/january.pdf. The value must be URL encoded.    To copy a specific version of an object, append ?versionId=&lt;version-id&gt; to the value (for example, awsexamplebucket/reports/january.pdf?versionId=QUpfdndhfd8438MNFDN93jdnJFkdmqnh893). If you don't specify a version ID, Amazon S3 copies the latest version of the source object.
        public let copySource: String
        /// Copies the object if its entity tag (ETag) matches the specified tag.
        public let copySourceIfMatch: String?
        /// Copies the object if it has been modified since the specified time.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var copySourceIfModifiedSince: Date?
        /// Copies the object if its entity tag (ETag) is different than the specified ETag.
        public let copySourceIfNoneMatch: String?
        /// Copies the object if it hasn't been modified since the specified time.
        @OptionalCustomCoding<HTTPHeaderDateCoder>
        public var copySourceIfUnmodifiedSince: Date?
        /// The range of bytes to copy from the source object. The range value must use the form bytes=first-last, where the first and last are the zero-based byte offsets to copy. For example, bytes=0-9 indicates that you want to copy the first 10 bytes of the source. You can copy a range only if the source object is greater than 5 MB.
        public let copySourceRange: String?
        /// Specifies the algorithm to use when decrypting the source object (for example, AES256).
        public let copySourceSSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use to decrypt the source object. The encryption key provided in this header must be one that was used when the source object was created.
        public let copySourceSSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let copySourceSSECustomerKeyMD5: String?
        /// The account id of the expected destination bucket owner. If the destination bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// The account id of the expected source bucket owner. If the source bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedSourceBucketOwner: String?
        /// Object key for which the multipart upload was initiated.
        public let key: String
        /// Part number of part being copied. This is a positive integer between 1 and 10,000.
        public let partNumber: Int
        public let requestPayer: RequestPayer?
        /// Specifies the algorithm to use to when encrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This value is used to store the object and then it is discarded; Amazon S3 does not store the encryption key. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header. This must be the same encryption key specified in the initiate multipart upload request.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// Upload ID identifying the multipart upload whose part is being copied.
        public let uploadId: String

        public init(bucket: String, copySource: String, copySourceIfMatch: String? = nil, copySourceIfModifiedSince: Date? = nil, copySourceIfNoneMatch: String? = nil, copySourceIfUnmodifiedSince: Date? = nil, copySourceRange: String? = nil, copySourceSSECustomerAlgorithm: String? = nil, copySourceSSECustomerKey: String? = nil, copySourceSSECustomerKeyMD5: String? = nil, expectedBucketOwner: String? = nil, expectedSourceBucketOwner: String? = nil, key: String, partNumber: Int, requestPayer: RequestPayer? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, uploadId: String) {
            self.bucket = bucket
            self.copySource = copySource
            self.copySourceIfMatch = copySourceIfMatch
            self.copySourceIfModifiedSince = copySourceIfModifiedSince
            self.copySourceIfNoneMatch = copySourceIfNoneMatch
            self.copySourceIfUnmodifiedSince = copySourceIfUnmodifiedSince
            self.copySourceRange = copySourceRange
            self.copySourceSSECustomerAlgorithm = copySourceSSECustomerAlgorithm
            self.copySourceSSECustomerKey = copySourceSSECustomerKey
            self.copySourceSSECustomerKeyMD5 = copySourceSSECustomerKeyMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.expectedSourceBucketOwner = expectedSourceBucketOwner
            self.key = key
            self.partNumber = partNumber
            self.requestPayer = requestPayer
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.uploadId = uploadId
        }

        public func validate(name: String) throws {
            try self.validate(self.copySource, name: "copySource", parent: name, pattern: ".+\\/.+")
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct UploadPartOutput: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "bucketKeyEnabled", location: .header(locationName: "x-amz-server-side-encryption-bucket-key-enabled")),
            AWSMemberEncoding(label: "eTag", location: .header(locationName: "ETag")),
            AWSMemberEncoding(label: "requestCharged", location: .header(locationName: "x-amz-request-charged")),
            AWSMemberEncoding(label: "serverSideEncryption", location: .header(locationName: "x-amz-server-side-encryption")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "sSEKMSKeyId", location: .header(locationName: "x-amz-server-side-encryption-aws-kms-key-id"))
        ]

        /// Indicates whether the multipart upload uses an S3 Bucket Key for server-side encryption with AWS KMS (SSE-KMS).
        public let bucketKeyEnabled: Bool?
        /// Entity tag for the uploaded object.
        public let eTag: String?
        public let requestCharged: RequestCharged?
        /// The server-side encryption algorithm used when storing this object in Amazon S3 (for example, AES256, aws:kms).
        public let serverSideEncryption: ServerSideEncryption?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header confirming the encryption algorithm used.
        public let sSECustomerAlgorithm: String?
        /// If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide round-trip message integrity verification of the customer-provided encryption key.
        public let sSECustomerKeyMD5: String?
        /// If present, specifies the ID of the AWS Key Management Service (AWS KMS) symmetric customer managed customer master key (CMK) was used for the object.
        public let sSEKMSKeyId: String?

        public init(bucketKeyEnabled: Bool? = nil, eTag: String? = nil, requestCharged: RequestCharged? = nil, serverSideEncryption: ServerSideEncryption? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKeyMD5: String? = nil, sSEKMSKeyId: String? = nil) {
            self.bucketKeyEnabled = bucketKeyEnabled
            self.eTag = eTag
            self.requestCharged = requestCharged
            self.serverSideEncryption = serverSideEncryption
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.sSEKMSKeyId = sSEKMSKeyId
        }

        private enum CodingKeys: String, CodingKey {
            case bucketKeyEnabled = "x-amz-server-side-encryption-bucket-key-enabled"
            case eTag = "ETag"
            case requestCharged = "x-amz-request-charged"
            case serverSideEncryption = "x-amz-server-side-encryption"
            case sSECustomerAlgorithm = "x-amz-server-side-encryption-customer-algorithm"
            case sSECustomerKeyMD5 = "x-amz-server-side-encryption-customer-key-MD5"
            case sSEKMSKeyId = "x-amz-server-side-encryption-aws-kms-key-id"
        }
    }

    public struct UploadPartRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "body"
        public static let _payloadOptions: AWSShapePayloadOptions = [.raw, .allowStreaming]
        public static var _encoding = [
            AWSMemberEncoding(label: "body", location: .body(locationName: "Body")),
            AWSMemberEncoding(label: "bucket", location: .uri(locationName: "Bucket")),
            AWSMemberEncoding(label: "contentLength", location: .header(locationName: "Content-Length")),
            AWSMemberEncoding(label: "contentMD5", location: .header(locationName: "Content-MD5")),
            AWSMemberEncoding(label: "expectedBucketOwner", location: .header(locationName: "x-amz-expected-bucket-owner")),
            AWSMemberEncoding(label: "key", location: .uri(locationName: "Key")),
            AWSMemberEncoding(label: "partNumber", location: .querystring(locationName: "partNumber")),
            AWSMemberEncoding(label: "requestPayer", location: .header(locationName: "x-amz-request-payer")),
            AWSMemberEncoding(label: "sSECustomerAlgorithm", location: .header(locationName: "x-amz-server-side-encryption-customer-algorithm")),
            AWSMemberEncoding(label: "sSECustomerKey", location: .header(locationName: "x-amz-server-side-encryption-customer-key")),
            AWSMemberEncoding(label: "sSECustomerKeyMD5", location: .header(locationName: "x-amz-server-side-encryption-customer-key-MD5")),
            AWSMemberEncoding(label: "uploadId", location: .querystring(locationName: "uploadId"))
        ]

        /// Object data.
        public let body: AWSPayload?
        /// The name of the bucket to which the multipart upload was initiated. When using this API with an access point, you must direct requests to the access point hostname. The access point hostname takes the form AccessPointName-AccountId.s3-accesspoint.Region.amazonaws.com. When using this operation with an access point through the AWS SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see Using Access Points in the Amazon Simple Storage Service Developer Guide. When using this API with Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form AccessPointName-AccountId.outpostID.s3-outposts.Region.amazonaws.com. When using this operation using S3 on Outposts through the AWS SDKs, you provide the Outposts bucket ARN in place of the bucket name. For more information about S3 on Outposts ARNs, see Using S3 on Outposts in the Amazon Simple Storage Service Developer Guide.
        public let bucket: String
        /// Size of the body in bytes. This parameter is useful when the size of the body cannot be determined automatically.
        public let contentLength: Int64?
        /// The base64-encoded 128-bit MD5 digest of the part data. This parameter is auto-populated when using the command from the CLI. This parameter is required if object lock parameters are specified.
        public let contentMD5: String?
        /// The account id of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.
        public let expectedBucketOwner: String?
        /// Object key for which the multipart upload was initiated.
        public let key: String
        /// Part number of part being uploaded. This is a positive integer between 1 and 10,000.
        public let partNumber: Int
        public let requestPayer: RequestPayer?
        /// Specifies the algorithm to use to when encrypting the object (for example, AES256).
        public let sSECustomerAlgorithm: String?
        /// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting data. This value is used to store the object and then it is discarded; Amazon S3 does not store the encryption key. The key must be appropriate for use with the algorithm specified in the x-amz-server-side-encryption-customer-algorithm header. This must be the same encryption key specified in the initiate multipart upload request.
        public let sSECustomerKey: String?
        /// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321. Amazon S3 uses this header for a message integrity check to ensure that the encryption key was transmitted without error.
        public let sSECustomerKeyMD5: String?
        /// Upload ID identifying the multipart upload whose part is being uploaded.
        public let uploadId: String

        public init(body: AWSPayload? = nil, bucket: String, contentLength: Int64? = nil, contentMD5: String? = nil, expectedBucketOwner: String? = nil, key: String, partNumber: Int, requestPayer: RequestPayer? = nil, sSECustomerAlgorithm: String? = nil, sSECustomerKey: String? = nil, sSECustomerKeyMD5: String? = nil, uploadId: String) {
            self.body = body
            self.bucket = bucket
            self.contentLength = contentLength
            self.contentMD5 = contentMD5
            self.expectedBucketOwner = expectedBucketOwner
            self.key = key
            self.partNumber = partNumber
            self.requestPayer = requestPayer
            self.sSECustomerAlgorithm = sSECustomerAlgorithm
            self.sSECustomerKey = sSECustomerKey
            self.sSECustomerKeyMD5 = sSECustomerKeyMD5
            self.uploadId = uploadId
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct VersioningConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"

        /// Specifies whether MFA delete is enabled in the bucket versioning configuration. This element is only returned if the bucket has been configured with MFA delete. If the bucket has never been so configured, this element is not returned.
        public let mFADelete: MFADelete?
        /// The versioning state of the bucket.
        public let status: BucketVersioningStatus?

        public init(mFADelete: MFADelete? = nil, status: BucketVersioningStatus? = nil) {
            self.mFADelete = mFADelete
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case mFADelete = "MfaDelete"
            case status = "Status"
        }
    }

    public struct WebsiteConfiguration: AWSEncodableShape {
        public static let _xmlNamespace: String? = "http://s3.amazonaws.com/doc/2006-03-01/"
        public struct _RoutingRulesEncoding: ArrayCoderProperties { public static let member = "RoutingRule" }

        /// The name of the error document for the website.
        public let errorDocument: ErrorDocument?
        /// The name of the index document for the website.
        public let indexDocument: IndexDocument?
        /// The redirect behavior for every request to this bucket's website endpoint.  If you specify this property, you can't specify any other property.
        public let redirectAllRequestsTo: RedirectAllRequestsTo?
        /// Rules that define when a redirect is applied and the redirect behavior.
        @OptionalCustomCoding<ArrayCoder<_RoutingRulesEncoding, RoutingRule>>
        public var routingRules: [RoutingRule]?

        public init(errorDocument: ErrorDocument? = nil, indexDocument: IndexDocument? = nil, redirectAllRequestsTo: RedirectAllRequestsTo? = nil, routingRules: [RoutingRule]? = nil) {
            self.errorDocument = errorDocument
            self.indexDocument = indexDocument
            self.redirectAllRequestsTo = redirectAllRequestsTo
            self.routingRules = routingRules
        }

        public func validate(name: String) throws {
            try self.errorDocument?.validate(name: "\(name).errorDocument")
        }

        private enum CodingKeys: String, CodingKey {
            case errorDocument = "ErrorDocument"
            case indexDocument = "IndexDocument"
            case redirectAllRequestsTo = "RedirectAllRequestsTo"
            case routingRules = "RoutingRules"
        }
    }
}
